diff --git a/layersvt/api_dump.h b/layersvt/api_dump.h
index 0fd0408cdf..d7f0aca45c 100644
--- a/layersvt/api_dump.h
+++ b/layersvt/api_dump.h
@@ -163,6 +163,13 @@ enum class ApiDumpFormat {
     Json,
 };
 
+enum class OutputConstruct {
+    pointer,
+    value,
+    api_struct,
+    api_union,
+};
+
 static const uint64_t OUTPUT_RANGE_UNLIMITED = 0;
 static const uint64_t OUTPUT_RANGE_INTERVAL_DEFAULT = 1;
 
@@ -495,7 +502,8 @@ class ApiDumpSettings {
             if (use_spaces)
                 output_stream << std::left << std::setw(type_size) << type << " = ";
             else
-                output_stream << type << std::setw((type_size - (int)strlen(type) - 1 + tab_size) / tab_size) << "" << " = ";
+                output_stream << type << std::setw((type_size - (int)strlen(type) - 1 + tab_size) / tab_size) << ""
+                              << " = ";
         } else {
             output_stream << " = ";
         }
@@ -507,8 +515,6 @@ class ApiDumpSettings {
         return "";
     }
 
-    bool shouldFlush() const { return should_flush; }
-
     bool shouldPreDump() const { return should_pre_dump; }
 
     bool showAddress() const { return show_address; }
@@ -804,6 +810,12 @@ class ApiDumpSettings {
         vkuDestroyLayerSettingSet(layerSettingSet, pAllocator);
     }
 
+    void flush() {
+        if (should_flush) {
+            output_stream.flush();
+        }
+    }
+
    private:
     // Utility member to enable easier comparison by forcing a string to all lower-case
     static std::string ToLowerString(const std::string &value) {
@@ -891,6 +903,7 @@ class ApiDumpInstance {
     std::mutex &outputMutex() { return output_mutex; }
 
     ApiDumpSettings &settings() { return dump_settings; }
+    ApiDumpSettings const &settings() const { return dump_settings; }
 
     uint64_t threadID() {
         std::thread::id this_id = std::this_thread::get_id();
@@ -964,28 +977,28 @@ class ApiDumpInstance {
     bool getIsDynamicScissor() const { return is_dynamic_scissor; }
     bool getIsDynamicViewport() const { return is_dynamic_viewport; }
     void setMemoryHeapCount(uint32_t memory_heap_count) { this->memory_heap_count = memory_heap_count; }
-    uint32_t getMemoryHeapCount() { return memory_heap_count; }
+    uint32_t getMemoryHeapCount() const { return memory_heap_count; }
     void setDescriptorType(VkDescriptorType type) { this->descriptor_type = type; }
     VkDescriptorType getDescriptorType() { return this->descriptor_type; }
     void setIsGPLPreRasterOrFragmentShader(bool in) { this->GPLPreRasterOrFragmentShader = in; }
-    bool getIsGPLPreRasterOrFragmentShader() { return this->GPLPreRasterOrFragmentShader; }
+    bool getIsGPLPreRasterOrFragmentShader() const { return this->GPLPreRasterOrFragmentShader; }
     void setIndirectExecutionSetInfoType(VkIndirectExecutionSetInfoTypeEXT type) { this->indirectExecutionSetInfoType = type; }
-    VkIndirectExecutionSetInfoTypeEXT getIndirectExecutionSetInfoType() { return this->indirectExecutionSetInfoType; }
+    VkIndirectExecutionSetInfoTypeEXT getIndirectExecutionSetInfoType() const { return this->indirectExecutionSetInfoType; }
     void setIndirectCommandsLayoutToken(VkIndirectCommandsTokenTypeEXT type) { this->indirectCommandsLayoutToken = type; }
-    VkIndirectCommandsTokenTypeEXT getIndirectCommandsLayoutToken() { return this->indirectCommandsLayoutToken; }
+    VkIndirectCommandsTokenTypeEXT getIndirectCommandsLayoutToken() const { return this->indirectCommandsLayoutToken; }
     void setDescriptorMappingSource(VkDescriptorMappingSourceEXT source) { this->descriptorMappingSource = source; }
-    VkDescriptorMappingSourceEXT getDescriptorMappingSource() { return this->descriptorMappingSource; }
+    VkDescriptorMappingSourceEXT getDescriptorMappingSource() const { return this->descriptorMappingSource; }
 
     void setSpsMaxSubLayersMinus1(uint8_t sps_max_sub_layers_minus1) {
         this->sps_max_sub_layers_minus1 = sps_max_sub_layers_minus1;
     }
-    uint8_t getSpsMaxSubLayersMinus1() { return sps_max_sub_layers_minus1; }
+    uint8_t getSpsMaxSubLayersMinus1() const { return sps_max_sub_layers_minus1; }
     void setVpsMaxSubLayersMinus1(uint8_t vps_max_sub_layers_minus1) {
         this->vps_max_sub_layers_minus1 = vps_max_sub_layers_minus1;
     }
-    uint8_t getVpsMaxSubLayersMinus1() { return vps_max_sub_layers_minus1; }
+    uint8_t getVpsMaxSubLayersMinus1() const { return vps_max_sub_layers_minus1; }
     void setIsInVps(bool is_in_vps) { this->is_in_vps = is_in_vps; }
-    bool getIsInVps() { return is_in_vps; }
+    bool getIsInVps() const { return is_in_vps; }
 
     std::chrono::microseconds current_time_since_start() {
         std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
@@ -1081,13 +1094,6 @@ class ApiDumpInstance {
     bool is_in_vps;
 };
 
-enum class OutputConstruct {
-    pointer,
-    value,
-    api_struct,
-    api_union,
-};
-
 // Helper function to determine the value of GPLPreRasterOrFragmentShader;
 inline bool checkForGPLPreRasterOrFragmentShader(const VkGraphicsPipelineCreateInfo &object) {
     VkGraphicsPipelineLibraryFlagsEXT flags{};
@@ -1102,686 +1108,645 @@ inline bool checkForGPLPreRasterOrFragmentShader(const VkGraphicsPipelineCreateI
     return flags &
            (VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT | VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT);
 }
+// -------- Dump functions --------------- //
 
-//==================================== Templated Helpers ======================================//
-
-inline void flush(const ApiDumpSettings &settings) {
-    if (settings.shouldFlush()) {
-        settings.stream().flush();
-    }
+inline void dump_value_start(ApiDumpInstance &api_dump) {
+    if (api_dump.settings().format() == ApiDumpFormat::Html) api_dump.settings().stream() << "<div class=\'val\'>";
+    if (api_dump.settings().format() == ApiDumpFormat::Json) api_dump.settings().stream() << " \"";
 }
 
-template <ApiDumpFormat Format>
-void dump_value_start(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Html) settings.stream() << "<div class=\'val\'>";
-    if constexpr (Format == ApiDumpFormat::Json) settings.stream() << " \"";
+inline void dump_value_end(ApiDumpInstance &api_dump) {
+    if (api_dump.settings().format() == ApiDumpFormat::Html) api_dump.settings().stream() << "</div>";
+    if (api_dump.settings().format() == ApiDumpFormat::Json) api_dump.settings().stream() << '"';
 }
 
-template <ApiDumpFormat Format>
-void dump_value_end(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Html) settings.stream() << "</div>";
-    if constexpr (Format == ApiDumpFormat::Json) settings.stream() << '"';
-}
-
-template <ApiDumpFormat Format, typename... T>
-void dump_value(const ApiDumpSettings &settings, T &&...values) {
-    dump_value_start<Format>(settings);
-    (settings.stream() << ... << values);
-    dump_value_end<Format>(settings);
-}
-
-template <ApiDumpFormat Format, typename... T>
-void dump_value_hex(const ApiDumpSettings &settings, T &&...values) {
-    dump_value_start<Format>(settings);
-    settings.stream() << "0x" << std::hex;
-    (settings.stream() << ... << values);
-    settings.stream() << std::dec;
-    dump_value_end<Format>(settings);
+template <typename... T>
+void dump_value(ApiDumpInstance &api_dump, T &&...values) {
+    dump_value_start(api_dump);
+    (api_dump.settings().stream() << ... << values);
+    dump_value_end(api_dump);
 }
 
-template <ApiDumpFormat Format>
-void dump_string(const ApiDumpSettings &settings, const char *name) {
-    dump_value<Format>(settings, name);
+template <typename T>
+void dump_value_hex(ApiDumpInstance &api_dump, T &&value) {
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << "0x" << std::hex << value << std::dec;
+    dump_value_end(api_dump);
 }
 
-template <ApiDumpFormat Format, typename T>
-void dump_enum_with_value(const ApiDumpSettings &settings, const char *name, T value) {
-    dump_value<Format>(settings, name, " (", value, ")");
+template <typename T>
+void dump_enum_with_value(ApiDumpInstance &api_dump, const char *name, T value) {
+    dump_value(api_dump, name, " (", value, ")");
 }
 
-template <ApiDumpFormat Format, typename T>
-void dump_enum(const ApiDumpSettings &settings, const char *name, T value) {
-    if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
-        dump_value<Format>(settings, name, " (", value, ")");
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        dump_value<Format>(settings, name);
+template <typename T>
+void dump_enum(ApiDumpInstance &api_dump, const char *name, T value) {
+    if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+        dump_value(api_dump, name, " (", value, ")");
+    } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+        dump_value(api_dump, name);
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_pNext_struct_name(const void *object, const ApiDumpSettings &settings, const char *type_name, const char *var_name,
+void dump_pNext_struct_name(ApiDumpInstance &api_dump, const void *object, const char *type_name, const char *var_name,
                             int indents);
 
-template <ApiDumpFormat Format>
-void dump_pNext_trampoline(const void *object, const ApiDumpSettings &settings, const char *type_name, const char *var_name,
-                           int indents);
+void dump_pNext_trampoline(ApiDumpInstance &api_dump, const void *object, const char *type_name, const char *var_name, int indents);
 
-template <ApiDumpFormat Format>
-void dump_pNext(const void *object, const ApiDumpSettings &settings, const char *type_string, const char *name, int indents) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        dump_pNext_struct_name<Format>(object, settings, type_string, name, indents);
-    } else if constexpr (Format == ApiDumpFormat::Html || Format == ApiDumpFormat::Json) {
-        dump_pNext_trampoline<Format>(object, settings, type_string, name, indents);
+inline void dump_pNext(ApiDumpInstance &api_dump, const void *object, const char *type_string, const char *name, int indents) {
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_struct_name(api_dump, object, type_string, name, indents);
+    } else if (api_dump.settings().format() == ApiDumpFormat::Html || api_dump.settings().format() == ApiDumpFormat::Json) {
+        dump_pNext_trampoline(api_dump, object, type_string, name, indents);
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_address(const ApiDumpSettings &settings, const void *address) {
+inline void dump_address(ApiDumpInstance &api_dump, const void *address) {
     if (address == NULL) {
         // TEMPORARY to minimize diff in output while developing.
-        if constexpr (Format == ApiDumpFormat::Json) {
-            dump_value<Format>(settings, "address");
+        if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_value(api_dump, "address");
         } else {
-            dump_value<Format>(settings, "NULL");
+            dump_value(api_dump, "NULL");
         }
-    } else if (settings.showAddress())
-        dump_value<Format>(settings, address);
+    } else if (api_dump.settings().showAddress())
+        dump_value(api_dump, address);
     else
-        dump_value<Format>(settings, "address");
+        dump_value(api_dump, "address");
 }
 
-template <ApiDumpFormat Format>
-void dump_separate_members(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Json) {
-        settings.stream() << ",\n";
+inline void dump_separate_members(ApiDumpInstance &api_dump) {
+    if (api_dump.settings().format() == ApiDumpFormat::Json) {
+        api_dump.settings().stream() << ",\n";
     }
 }
 
 //============================== Json formatting helper functions ==============================//
 
-inline void dump_json_key_start_array(const ApiDumpSettings &settings, int indents, const char *key) {
-    settings.stream() << settings.indentation(indents) << "\"" << key << "\" :\n" << settings.indentation(indents) << "[\n";
+inline void dump_json_key_start_array(ApiDumpInstance &api_dump, int indents, const char *key) {
+    api_dump.settings().stream() << api_dump.settings().indentation(indents) << "\"" << key << "\" :\n"
+                                 << api_dump.settings().indentation(indents) << "[\n";
 }
-inline void dump_json_end_array(const ApiDumpSettings &settings, int indents) {
-    settings.stream() << settings.indentation(indents) << "]";
+inline void dump_json_end_array(ApiDumpInstance &api_dump, int indents) {
+    api_dump.settings().stream() << api_dump.settings().indentation(indents) << "]";
 }
-inline void dump_json_newline_end_array(const ApiDumpSettings &settings, int indents) {
-    settings.stream() << "\n";
-    dump_json_end_array(settings, indents);
+inline void dump_json_newline_end_array(ApiDumpInstance &api_dump, int indents) {
+    api_dump.settings().stream() << "\n";
+    dump_json_end_array(api_dump, indents);
 }
-inline void dump_json_start_object(const ApiDumpSettings &settings, int indents) {
-    settings.stream() << settings.indentation(indents) << "{\n";
+inline void dump_json_start_object(ApiDumpInstance &api_dump, int indents) {
+    api_dump.settings().stream() << api_dump.settings().indentation(indents) << "{\n";
 }
-inline void dump_json_end_object(const ApiDumpSettings &settings, int indents) {
-    settings.stream() << "\n" << settings.indentation(indents) << "}";
+inline void dump_json_end_object(ApiDumpInstance &api_dump, int indents) {
+    api_dump.settings().stream() << "\n" << api_dump.settings().indentation(indents) << "}";
 }
-inline void dump_json_key(const ApiDumpSettings &settings, int indents, const char *key) {
-    settings.stream() << settings.indentation(indents) << "\"" << key << "\" :";
+inline void dump_json_key(ApiDumpInstance &api_dump, int indents, const char *key) {
+    api_dump.settings().stream() << api_dump.settings().indentation(indents) << "\"" << key << "\" :";
 }
 
 template <typename... T>
-void dump_json_key_value(const ApiDumpSettings &settings, int indents, const char *key, T &&...values) {
-    dump_json_key(settings, indents, key);
-    dump_value<ApiDumpFormat::Json>(settings, values...);
+void dump_json_key_value(ApiDumpInstance &api_dump, int indents, const char *key, T &&...values) {
+    dump_json_key(api_dump, indents, key);
+    dump_value(api_dump, values...);
 }
 
-inline void dump_json_key_address(const ApiDumpSettings &settings, int indents, const void *address) {
-    dump_json_key(settings, indents, "address");
-    dump_address<ApiDumpFormat::Json>(settings, address);
+inline void dump_json_key_address(ApiDumpInstance &api_dump, int indents, const void *address) {
+    dump_json_key(api_dump, indents, "address");
+    dump_address(api_dump, address);
 }
 
 //================================ Common Output Functions ================================//
 
-template <ApiDumpFormat Format>
-void dump_start(const ApiDumpSettings &settings, OutputConstruct construct, const char *type_string, const char *name, int indents,
-                const void *address = nullptr) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        settings.formatNameType(indents, name, type_string);
-        if (construct == OutputConstruct::pointer) {
-            dump_address<Format>(settings, address);
-        } else if (construct == OutputConstruct::api_struct || construct == OutputConstruct::api_union) {
-            if (settings.showAddress())
-                dump_value<Format>(settings, address);
-            else
-                dump_value<Format>(settings, "address");
-            if (construct == OutputConstruct::api_struct) {
-                settings.stream() << ":\n";
-            } else if (construct == OutputConstruct::api_union) {
-                settings.stream() << " (Union):\n";
+inline void dump_start(ApiDumpInstance &api_dump, OutputConstruct construct, const char *type_string, const char *name, int indents,
+                       const void *address = nullptr) {
+    auto &settings = api_dump.settings();
+
+    switch (settings.format()) {
+        case (ApiDumpFormat::Text): {
+            settings.formatNameType(indents, name, type_string);
+            if (construct == OutputConstruct::pointer) {
+                dump_address(api_dump, address);
+            } else if (construct == OutputConstruct::api_struct || construct == OutputConstruct::api_union) {
+                if (settings.showAddress())
+                    dump_value(api_dump, address);
+                else
+                    dump_value(api_dump, "address");
+                if (construct == OutputConstruct::api_struct) {
+                    settings.stream() << ":\n";
+                } else if (construct == OutputConstruct::api_union) {
+                    settings.stream() << " (Union):\n";
+                }
             }
         }
-
-    } else if constexpr (Format == ApiDumpFormat::Html) {
-        settings.stream() << "<details class='data'><summary>";
-        settings.stream() << "<div class='var'>" << name << "</div>";
-        if (settings.showType()) {
-            settings.stream() << "<div class='type'>" << type_string << "</div>";
+        case (ApiDumpFormat::Html): {
+            settings.stream() << "<details class='data'><summary>";
+            settings.stream() << "<div class='var'>" << name << "</div>";
+            if (settings.showType()) {
+                settings.stream() << "<div class='type'>" << type_string << "</div>";
+            }
+            if (construct == OutputConstruct::pointer) {
+                dump_address(api_dump, address);
+            } else if (construct == OutputConstruct::api_struct) {
+                if (settings.showAddress())
+                    dump_value(api_dump, address, "\n");
+                else
+                    dump_value(api_dump, "address\n");
+                settings.stream() << "</summary>";
+            } else if (construct == OutputConstruct::api_union) {
+                if (settings.showAddress())
+                    dump_value(api_dump, address, " (Union):\n");
+                else
+                    dump_value(api_dump, "address (Union):\n");
+                settings.stream() << "</summary>";
+            }
         }
-        if (construct == OutputConstruct::pointer) {
-            dump_address<Format>(settings, address);
-        } else if (construct == OutputConstruct::api_struct) {
-            if (settings.showAddress())
-                dump_value<Format>(settings, address, "\n");
-            else
-                dump_value<Format>(settings, "address\n");
-            settings.stream() << "</summary>";
-        } else if (construct == OutputConstruct::api_union) {
-            if (settings.showAddress())
-                dump_value<Format>(settings, address, " (Union):\n");
+        case (ApiDumpFormat::Json): {
+            dump_json_start_object(api_dump, indents);
+            if (construct == OutputConstruct::api_union)
+                dump_json_key_value(api_dump, indents + 1, "type", type_string, " (Union)");
             else
-                dump_value<Format>(settings, "address (Union):\n");
-            settings.stream() << "</summary>";
-        }
-
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        dump_json_start_object(settings, indents);
-        if (construct == OutputConstruct::api_union)
-            dump_json_key_value(settings, indents + 1, "type", type_string, " (Union)");
-        else
-            dump_json_key_value(settings, indents + 1, "type", type_string);
+                dump_json_key_value(api_dump, indents + 1, "type", type_string);
 
-        dump_separate_members<ApiDumpFormat::Json>(settings);
-        dump_json_key_value(settings, indents + 1, "name", name);
+            dump_separate_members(api_dump);
+            dump_json_key_value(api_dump, indents + 1, "name", name);
 
-        if (construct == OutputConstruct::pointer || address != nullptr) {
-            dump_separate_members<ApiDumpFormat::Json>(settings);
-            dump_json_key_address(settings, indents + 1, address);
-        }
-        if (construct != OutputConstruct::pointer) {
-            dump_separate_members<ApiDumpFormat::Json>(settings);
-            if (construct == OutputConstruct::value) {
-                dump_json_key(settings, indents + 1, "value");
-            } else if (construct == OutputConstruct::api_struct || construct == OutputConstruct::api_union) {
-                dump_json_key_start_array(settings, indents + 1, "members");
+            if (construct == OutputConstruct::pointer || address != nullptr) {
+                dump_separate_members(api_dump);
+                dump_json_key_address(api_dump, indents + 1, address);
+            }
+            if (construct != OutputConstruct::pointer) {
+                dump_separate_members(api_dump);
+                if (construct == OutputConstruct::value) {
+                    dump_json_key(api_dump, indents + 1, "value");
+                } else if (construct == OutputConstruct::api_struct || construct == OutputConstruct::api_union) {
+                    dump_json_key_start_array(api_dump, indents + 1, "members");
+                }
             }
         }
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_end(const ApiDumpSettings &settings, OutputConstruct construct, int indents) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (construct == OutputConstruct::value || construct == OutputConstruct::pointer) settings.stream() << "\n";
-
-    } else if constexpr (Format == ApiDumpFormat::Html) {
-        if (construct == OutputConstruct::value || construct == OutputConstruct::pointer) {
-            settings.stream() << "</summary></details>";
-        } else {
-            settings.stream() << "</details>";
+inline void dump_end(ApiDumpInstance &api_dump, OutputConstruct construct, int indents) {
+    auto &settings = api_dump.settings();
+    switch (settings.format()) {
+        case (ApiDumpFormat::Text): {
+            if (construct == OutputConstruct::value || construct == OutputConstruct::pointer) settings.stream() << "\n";
         }
-
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        if (construct == OutputConstruct::api_struct || construct == OutputConstruct::api_union) {
-            dump_json_newline_end_array(settings, indents + 1);
+        case (ApiDumpFormat::Html): {
+            if (construct == OutputConstruct::value || construct == OutputConstruct::pointer) {
+                settings.stream() << "</summary></details>";
+            } else {
+                settings.stream() << "</details>";
+            }
+        }
+        case (ApiDumpFormat::Json): {
+            if (construct == OutputConstruct::api_struct || construct == OutputConstruct::api_union) {
+                dump_json_newline_end_array(api_dump, indents + 1);
+            }
+            dump_json_end_object(api_dump, indents);
         }
-        dump_json_end_object(settings, indents);
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_nullptr(const ApiDumpSettings &settings, const char *type_string, const char *name, int indents) {
-    dump_start<Format>(settings, OutputConstruct::pointer, type_string, name, indents);
-    dump_end<Format>(settings, OutputConstruct::pointer, indents);
+inline void dump_nullptr(ApiDumpInstance &api_dump, const char *type_string, const char *name, int indents) {
+    dump_start(api_dump, OutputConstruct::pointer, type_string, name, indents);
+    dump_end(api_dump, OutputConstruct::pointer, indents);
 }
 
-template <ApiDumpFormat Format>
-void dump_char(const char *object, const ApiDumpSettings &settings, const char *type_string, const char *name, int indents,
-               const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_string, name, indents, address);
-    if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
+inline void dump_char(ApiDumpInstance &api_dump, const char *object, const char *type_string, const char *name, int indents,
+                      const void *address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_string, name, indents, address);
+    if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
         if (object == NULL)
-            dump_value<Format>(settings, "NULL");
+            dump_value(api_dump, "NULL");
         else
-            dump_value<Format>(settings, '"', object, '"');
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        dump_value<Format>(settings, (object != NULL ? object : ""));
+            dump_value(api_dump, '"', object, '"');
+    } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+        dump_value(api_dump, (object != NULL ? object : ""));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-template <ApiDumpFormat Format>
-void dump_void(const void *object, const ApiDumpSettings &settings, const char *type_string, const char *name, int indents,
-               const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::pointer, type_string, name, indents, object);
-    dump_end<Format>(settings, OutputConstruct::pointer, indents);
+inline void dump_void(ApiDumpInstance &api_dump, const void *object, const char *type_string, const char *name, int indents,
+                      const void *address = nullptr) {
+    dump_start(api_dump, OutputConstruct::pointer, type_string, name, indents, object);
+    dump_end(api_dump, OutputConstruct::pointer, indents);
 }
 
-template <ApiDumpFormat Format>
-void dump_api_version(uint32_t api_version, const ApiDumpSettings &settings, const char *type_string, const char *name, int indents,
-                      const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_string, name, indents, address);
-    dump_value<Format>(settings, api_version, " (", VK_API_VERSION_MAJOR(api_version), ".", VK_API_VERSION_MINOR(api_version), ".",
-                       VK_API_VERSION_PATCH(api_version), ")");
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+inline void dump_api_version(ApiDumpInstance &api_dump, uint32_t api_version, const char *type_string, const char *name,
+                             int indents, const void *address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_string, name, indents, address);
+    dump_value(api_dump, api_version, " (", VK_API_VERSION_MAJOR(api_version), ".", VK_API_VERSION_MINOR(api_version), ".",
+               VK_API_VERSION_PATCH(api_version), ")");
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-template <ApiDumpFormat Format>
-void dump_special(const char *const &text, const ApiDumpSettings &settings, const char *type_string, const char *name,
-                  int indents) {
-    dump_start<Format>(settings, OutputConstruct::value, type_string, name, indents, text);
-    dump_value<Format>(settings, text);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+inline void dump_special(ApiDumpInstance &api_dump, const char *const &text, const char *type_string, const char *name,
+                         int indents) {
+    dump_start(api_dump, OutputConstruct::value, type_string, name, indents, text);
+    dump_value(api_dump, text);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-template <ApiDumpFormat Format, typename T>
-void dump_handle(T object, const ApiDumpSettings &settings, const char *type_string, const char *name, int indents,
+template <typename T>
+void dump_handle(ApiDumpInstance &api_dump, T object, const char *type_string, const char *name, int indents,
                  const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_string, name, indents, address);
-    if (settings.showAddress()) {
-        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
+    dump_start(api_dump, OutputConstruct::value, type_string, name, indents, address);
+    if (api_dump.settings().showAddress()) {
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
             std::unordered_map<uint64_t, std::string>::const_iterator it =
                 ApiDumpInstance::current().object_name_map.find((uint64_t)object);
             if (it != ApiDumpInstance::current().object_name_map.end()) {
-                dump_value<Format>(settings, object, " [", it->second, "]");
+                dump_value(api_dump, object, " [", it->second, "]");
             } else {
-                dump_value<Format>(settings, object);
+                dump_value(api_dump, object);
             }
-        } else if constexpr (Format == ApiDumpFormat::Json) {
-            dump_value<Format>(settings, object);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_value(api_dump, object);
         }
     } else {
-        dump_value<Format>(settings, "address");
+        dump_value(api_dump, "address");
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-template <ApiDumpFormat Format, typename T>
-std::enable_if_t<!std::is_pointer_v<T>> dump_type(const T &object, const ApiDumpSettings &settings, const char *type_string,
+template <typename T>
+std::enable_if_t<!std::is_pointer_v<T>> dump_type(ApiDumpInstance &api_dump, const T &object, const char *type_string,
                                                   const char *name, int indents, const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_string, name, indents, address);
-    dump_value<Format>(settings, object);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_start(api_dump, OutputConstruct::value, type_string, name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-template <ApiDumpFormat Format, typename T>
-std::enable_if_t<std::is_pointer_v<T>> dump_type(const T &object, const ApiDumpSettings &settings, const char *type_string,
+template <typename T>
+std::enable_if_t<std::is_pointer_v<T>> dump_type(ApiDumpInstance &api_dump, const T &object, const char *type_string,
                                                  const char *name, int indents, const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::pointer, type_string, name, indents, object);
-    dump_end<Format>(settings, OutputConstruct::pointer, indents);
+    dump_start(api_dump, OutputConstruct::pointer, type_string, name, indents, object);
+    dump_end(api_dump, OutputConstruct::pointer, indents);
 }
 
-template <ApiDumpFormat Format, typename T>
-std::enable_if_t<!std::is_pointer_v<T>> dump_type_hex(const T &object, const ApiDumpSettings &settings, const char *type_string,
+template <typename T>
+std::enable_if_t<!std::is_pointer_v<T>> dump_type_hex(ApiDumpInstance &api_dump, const T &object, const char *type_string,
                                                       const char *name, int indents, const void *address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_string, name, indents, address);
-    dump_value_hex<Format>(settings, object);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_start(api_dump, OutputConstruct::value, type_string, name, indents, address);
+    dump_value_hex(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-template <ApiDumpFormat Format>
-void dump_uint64_t_as_pointer(const uint64_t object, const ApiDumpSettings &settings, const char *type_string, const char *name,
-                              int indents) {
-    dump_start<Format>(settings, OutputConstruct::pointer, type_string, name, indents,
-                       reinterpret_cast<const void *>(static_cast<uintptr_t>(object)));
-    dump_end<Format>(settings, OutputConstruct::pointer, indents);
+inline void dump_uint64_t_as_pointer(ApiDumpInstance &api_dump, const uint64_t object, const char *type_string, const char *name,
+                                     int indents) {
+    dump_start(api_dump, OutputConstruct::pointer, type_string, name, indents,
+               reinterpret_cast<const void *>(static_cast<uintptr_t>(object)));
+    dump_end(api_dump, OutputConstruct::pointer, indents);
 }
 
-template <ApiDumpFormat Format, typename T, typename DumpValue>
-void dump_pointer(const T *object, const ApiDumpSettings &settings, const char *type_string, const char *name, int indents,
+template <typename T, typename DumpValue>
+void dump_pointer(ApiDumpInstance &api_dump, const T *object, const char *type_string, const char *name, int indents,
                   DumpValue dump_value) {
     if (object == NULL) {
-        dump_nullptr<Format>(settings, type_string, name, indents);
+        dump_nullptr(api_dump, type_string, name, indents);
     } else {
-        dump_value(*object, settings, type_string, name, indents, object);
+        dump_value(api_dump, *object, type_string, name, indents, object);
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_array_start(const void *array, size_t len, const ApiDumpSettings &settings, const char *type_string, const char *name,
-                      int indents) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        dump_start<Format>(settings, OutputConstruct::pointer, type_string, name, indents, array);
-        settings.stream() << "\n";
-    } else if constexpr (Format == ApiDumpFormat::Html) {
-        dump_start<Format>(settings, OutputConstruct::api_struct, type_string, name, indents, array);
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        dump_json_start_object(settings, indents);
-        dump_json_key_value(settings, indents + 1, "type", type_string);
-        dump_separate_members<Format>(settings);
-        dump_json_key_value(settings, indents + 1, "name", name);
-        dump_separate_members<Format>(settings);
-        dump_json_key_address(settings, indents + 1, array);
+inline void dump_array_start(ApiDumpInstance &api_dump, const void *array, size_t len, const char *type_string, const char *name,
+                             int indents) {
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_start(api_dump, OutputConstruct::pointer, type_string, name, indents, array);
+        api_dump.settings().stream() << "\n";
+    } else if (api_dump.settings().format() == ApiDumpFormat::Html) {
+        dump_start(api_dump, OutputConstruct::api_struct, type_string, name, indents, array);
+    } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+        dump_json_start_object(api_dump, indents);
+        dump_json_key_value(api_dump, indents + 1, "type", type_string);
+        dump_separate_members(api_dump);
+        dump_json_key_value(api_dump, indents + 1, "name", name);
+        dump_separate_members(api_dump);
+        dump_json_key_address(api_dump, indents + 1, array);
         if (len > 0 && array != NULL) {
-            dump_separate_members<Format>(settings);
-            dump_json_key_start_array(settings, indents + 1, "elements");
+            dump_separate_members(api_dump);
+            dump_json_key_start_array(api_dump, indents + 1, "elements");
         } else {
-            settings.stream() << "\n";
+            api_dump.settings().stream() << "\n";
         }
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_array_end(const void *array, size_t len, const ApiDumpSettings &settings, int indents) {
-    if constexpr (Format == ApiDumpFormat::Html) {
-        dump_end<ApiDumpFormat::Html>(settings, OutputConstruct::api_struct, indents);
-    } else if constexpr (Format == ApiDumpFormat::Json) {
+inline void dump_array_end(ApiDumpInstance &api_dump, const void *array, size_t len, int indents) {
+    if (api_dump.settings().format() == ApiDumpFormat::Html) {
+        dump_end(api_dump, OutputConstruct::api_struct, indents);
+    } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
         if (len > 0 && array != NULL) {
-            dump_json_end_array(settings, indents + 1);
+            dump_json_end_array(api_dump, indents + 1);
         }
-        dump_json_end_object(settings, indents);
+        dump_json_end_object(api_dump, indents);
     }
 }
 
-template <ApiDumpFormat Format, size_t N, typename T, typename DumpElement>
-void dump_double_array(const T(array)[][N], size_t len1, size_t len2, const ApiDumpSettings &settings, const char *type_string,
+template <size_t N, typename T, typename DumpElement>
+void dump_double_array(ApiDumpInstance &api_dump, const T(array)[][N], size_t len1, size_t len2, const char *type_string,
                        const char *name, const char *element_type, int indents, DumpElement dump_element) {
     if (len1 == 0 || len2 == 0) {
         return;
     }
-    dump_array_start<Format>(array, len1 * len2, settings, type_string, name, indents);
+    dump_array_start(api_dump, array, len1 * len2, type_string, name, indents);
     for (size_t i = 0; i < len1; ++i) {
         for (size_t j = 0; j < len2; ++j) {
             std::stringstream stream;
-            if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
-                stream << name;
+            if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+                api_dump.settings().stream() << name;
             }
-            stream << "[" << i << "][" << j << "]";
+            api_dump.settings().stream() << "[" << i << "][" << j << "]";
             std::string indexName = stream.str();
-            dump_element(array[i][j], settings, element_type, indexName.c_str(), indents + (Format == ApiDumpFormat::Json ? 2 : 1),
-                         nullptr);
-            if constexpr (Format == ApiDumpFormat::Json) {
-                if (i < len1 - 1 && j < len2 - 1) settings.stream() << ',';
-                settings.stream() << "\n";
+            dump_element(api_dump, array[i][j], element_type, indexName.c_str(),
+                         indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), nullptr);
+            if (api_dump.settings().format() == ApiDumpFormat::Json) {
+                if (i < len1 - 1 && j < len2 - 1) api_dump.settings().stream() << ',';
+                api_dump.settings().stream() << "\n";
             }
         }
     }
-    dump_array_end<Format>(array, len1 * len2, settings, indents);
+    dump_array_end(api_dump, array, len1 * len2, indents);
 }
 
-template <ApiDumpFormat Format, size_t N, typename T, typename DumpElement>
-void dump_single_array(const T (&array)[N], size_t len, const ApiDumpSettings &settings, const char *type_string, const char *name,
+template <size_t N, typename T, typename DumpElement>
+void dump_single_array(ApiDumpInstance &api_dump, const T (&array)[N], size_t len, const char *type_string, const char *name,
                        const char *element_type, int indents, DumpElement dump_element) {
     if (len == 0) {
         return;
     }
-    dump_array_start<Format>(array, len, settings, type_string, name, indents);
+    dump_array_start(api_dump, array, len, type_string, name, indents);
     for (size_t i = 0; i < len; ++i) {
         std::stringstream stream;
-        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
-            stream << name;
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            api_dump.settings().stream() << name;
         }
-        stream << "[" << i << "]";
+        api_dump.settings().stream() << "[" << i << "]";
         std::string indexName = stream.str();
-        dump_element(array[i], settings, element_type, indexName.c_str(), indents + (Format == ApiDumpFormat::Json ? 2 : 1),
-                     nullptr);
-        if constexpr (Format == ApiDumpFormat::Json) {
-            if (i < len - 1) settings.stream() << ',';
-            settings.stream() << "\n";
+        dump_element(api_dump, array[i], element_type, indexName.c_str(),
+                     indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), nullptr);
+        if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            if (i < len - 1) api_dump.settings().stream() << ',';
+            api_dump.settings().stream() << "\n";
         }
     }
-    dump_array_end<Format>(array, len, settings, indents);
+    dump_array_end(api_dump, array, len, indents);
 }
 
-template <ApiDumpFormat Format, typename T, typename DumpElement>
-void dump_pointer_array(const T *array, size_t len, const ApiDumpSettings &settings, const char *type_string, const char *name,
+template <typename T, typename DumpElement>
+void dump_pointer_array(ApiDumpInstance &api_dump, const T *array, size_t len, const char *type_string, const char *name,
                         const char *element_type, int indents, DumpElement dump_element) {
     if (array == NULL || len == 0) {
-        dump_nullptr<Format>(settings, type_string, name, indents);
+        dump_nullptr(api_dump, type_string, name, indents);
         return;
     }
-    dump_array_start<Format>(array, len, settings, type_string, name, indents);
+    dump_array_start(api_dump, array, len, type_string, name, indents);
     for (size_t i = 0; i < len; ++i) {
         std::stringstream stream;
-        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
-            stream << name;
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            api_dump.settings().stream() << name;
         }
-        stream << "[" << i << "]";
+        api_dump.settings().stream() << "[" << i << "]";
         std::string indexName = stream.str();
-        dump_element(array[i], settings, element_type, indexName.c_str(), indents + (Format == ApiDumpFormat::Json ? 2 : 1),
-                     array + i);
-        if constexpr (Format == ApiDumpFormat::Json) {
-            if (i < len - 1) settings.stream() << ',';
-            settings.stream() << "\n";
+        dump_element(api_dump, array[i], element_type, indexName.c_str(),
+                     indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), array + i);
+        if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            if (i < len - 1) api_dump.settings().stream() << ',';
+            api_dump.settings().stream() << "\n";
         }
     }
-    dump_array_end<Format>(array, len, settings, indents);
+    dump_array_end(api_dump, array, len, indents);
 }
 
-template <ApiDumpFormat Format, typename T, typename DumpElement>
-void dump_double_pointer_array(const T *const *array, size_t len, const ApiDumpSettings &settings, const char *type_string,
+template <typename T, typename DumpElement>
+void dump_double_pointer_array(ApiDumpInstance &api_dump, const T *const *array, size_t len, const char *type_string,
                                const char *name, const char *element_type, int indents, DumpElement dump_element) {
     if (array == nullptr || len == 0) {
-        dump_nullptr<Format>(settings, type_string, name, indents);
+        dump_nullptr(api_dump, type_string, name, indents);
         return;
     }
-    dump_array_start<Format>(array, len, settings, type_string, name, indents);
+    dump_array_start(api_dump, array, len, type_string, name, indents);
     for (size_t i = 0; i < len; ++i) {
         std::stringstream stream;
-        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
-            stream << name;
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            api_dump.settings().stream() << name;
         }
-        stream << "[" << i << "]";
+        api_dump.settings().stream() << "[" << i << "]";
         std::string indexName = stream.str();
-        dump_pointer<Format>(array[i], settings, element_type, indexName.c_str(), indents + (Format == ApiDumpFormat::Json ? 2 : 1),
-                             dump_element);
-        if constexpr (Format == ApiDumpFormat::Json) {
-            if (i < len - 1) settings.stream() << ',';
-            settings.stream() << "\n";
+        dump_pointer(api_dump, array[i], element_type, indexName.c_str(),
+                     indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_element);
+        if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            if (i < len - 1) api_dump.settings().stream() << ',';
+            api_dump.settings().stream() << "\n";
         }
     }
-    dump_array_end<Format>(array, len, settings, indents);
+    dump_array_end(api_dump, array, len, indents);
 }
 
 // Designed to be viewed in something like https://www.khronos.org/spir/visualizer/
 // There is also now support in SPIRV-Tools (https://github.com/KhronosGroup/SPIRV-Tools/pull/5870) to consume the array
-template <ApiDumpFormat Format, typename T>
-void dump_spirv(const T *array, size_t len, const ApiDumpSettings &settings, const char *type_string, const char *name,
-                int indents) {
+template <typename T>
+void dump_spirv(ApiDumpInstance &api_dump, const T *array, size_t len, const char *type_string, const char *name, int indents) {
     if (array == NULL || len == 0) {
-        dump_nullptr<Format>(settings, type_string, name, indents);
+        dump_nullptr(api_dump, type_string, name, indents);
         return;
     }
-    dump_array_start<Format>(array, len, settings, type_string, name, indents);
+    dump_array_start(api_dump, array, len, type_string, name, indents);
 
     std::stringstream stream;
     // For JSON we will just dump it as a valid JSON array of string like
     // [ "0x07230203", "0x00010300", "0x0008000b", ...
-    if constexpr (Format == ApiDumpFormat::Json) {
+    if (api_dump.settings().format() == ApiDumpFormat::Json) {
         for (size_t i = 0; i < len; ++i) {
             if (i != 0) {
-                stream << ", ";
+                api_dump.settings().stream() << ", ";
             }
             const uint32_t dword = static_cast<const uint32_t *>(array)[i];
-            stream << "\"0x" << std::hex << std::setfill('0') << std::setw(8) << dword << "\"";
+            api_dump.settings().stream() << "\"0x" << std::hex << std::setfill('0') << std::setw(8) << dword << "\"";
         }
-        settings.stream() << stream.str();
+        api_dump.settings().stream() << stream.str();
     } else {
-        stream << settings.indentation(indents) << "[ ";
+        api_dump.settings().stream() << api_dump.settings().indentation(indents) << "[ ";
         for (size_t i = 0; i < len; ++i) {
             if (i != 0) {
-                stream << ", ";
+                api_dump.settings().stream() << ", ";
             }
             const uint32_t dword = static_cast<const uint32_t *>(array)[i];
-            stream << "0x" << std::hex << std::setfill('0') << std::setw(8) << dword;
+            api_dump.settings().stream() << "0x" << std::hex << std::setfill('0') << std::setw(8) << dword;
         }
-        stream << " ]\n";
-        dump_value<Format>(settings, stream.str());
+        api_dump.settings().stream() << " ]\n";
+        dump_value(api_dump, stream.str());
     }
 
-    dump_array_end<Format>(array, len, settings, indents);
+    dump_array_end(api_dump, array, len, indents);
 }
 
-template <ApiDumpFormat Format>
-void dump_before_pre_dump_formatting(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump()) {
-            settings.stream() << "<before calling into implementation>\n";
+inline void dump_before_pre_dump_formatting(ApiDumpInstance &api_dump) {
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump()) {
+            api_dump.settings().stream() << "<before calling into implementation>\n";
         }
     }
 }
 
-template <ApiDumpFormat Format, typename T>
-void dump_return_value(const ApiDumpSettings &settings, const char *returnType, T result) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump()) {
+template <typename T>
+void dump_return_value(ApiDumpInstance &api_dump, const char *returnType, T result) {
+    auto &settings = api_dump.settings();
+
+    if (settings.format() == ApiDumpFormat::Text) {
+        if (settings.shouldPreDump()) {
             settings.stream() << "return " << returnType;
         }
         settings.stream() << " ";
 
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        dump_separate_members<Format>(settings);
-        dump_json_key(settings, 3, "returnValue");
+    } else if (settings.format() == ApiDumpFormat::Json) {
+        dump_separate_members(api_dump);
+        dump_json_key(api_dump, 3, "returnValue");
     }
-    dump_value<Format>(settings, result);
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump()) {
+    dump_value(api_dump, result);
+    if (settings.format() == ApiDumpFormat::Text) {
+        if (settings.shouldPreDump()) {
             settings.stream() << ":\n";
         }
     }
 }
 
-template <ApiDumpFormat Format, typename T, typename DumpReturnValue>
-void dump_return_value(const ApiDumpSettings &settings, const char *returnType, T result, DumpReturnValue dump_return_value) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump()) {
+template <typename T, typename DumpReturnValue>
+void dump_return_value(ApiDumpInstance &api_dump, const char *returnType, T result, DumpReturnValue dump_return_value) {
+    auto &settings = api_dump.settings();
+
+    if (settings.format() == ApiDumpFormat::Text) {
+        if (settings.shouldPreDump()) {
             settings.stream() << "return " << returnType;
         }
         settings.stream() << " ";
 
-    } else if constexpr (Format == ApiDumpFormat::Json) {
-        dump_separate_members<Format>(settings);
-        dump_json_key(settings, 3, "returnValue");
+    } else if (settings.format() == ApiDumpFormat::Json) {
+        dump_separate_members(api_dump);
+        dump_json_key(api_dump, 3, "returnValue");
     }
-    dump_return_value(result, settings);
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump()) {
+    dump_return_value(api_dump, result);
+    if (settings.format() == ApiDumpFormat::Text) {
+        if (settings.shouldPreDump()) {
             settings.stream() << ":\n";
         }
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_pre_params_formatting(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Json) {
-        dump_separate_members<Format>(settings);
-        dump_json_key_start_array(settings, 3, "args");
+inline void dump_pre_params_formatting(ApiDumpInstance &api_dump) {
+    if (api_dump.settings().format() == ApiDumpFormat::Json) {
+        dump_separate_members(api_dump);
+        dump_json_key_start_array(api_dump, 3, "args");
     }
 }
-template <ApiDumpFormat Format>
-void dump_post_params_formatting(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
+
+inline void dump_post_params_formatting(ApiDumpInstance &api_dump) {
+    auto &settings = api_dump.settings();
+
+    if (settings.format() == ApiDumpFormat::Text || settings.format() == ApiDumpFormat::Html) {
         settings.stream() << "\n";
-    } else if constexpr (Format == ApiDumpFormat::Json) {
+    } else if (settings.format() == ApiDumpFormat::Json) {
         settings.stream() << "\n" << settings.indentation(3) << "]\n";
     }
 }
 
-template <ApiDumpFormat Format>
-void dump_pre_function_formatting(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump()) {
+inline void dump_pre_function_formatting(ApiDumpInstance &api_dump) {
+    auto &settings = api_dump.settings();
+
+    if (settings.format() == ApiDumpFormat::Text) {
+        if (settings.shouldPreDump()) {
             settings.stream() << "<after returning from implementation>\n";
         } else {
             settings.stream() << ":\n";
         }
-    } else if constexpr (Format == ApiDumpFormat::Html) {
+    } else if (settings.format() == ApiDumpFormat::Html) {
         settings.stream() << "</summary>";
     }
 }
-template <ApiDumpFormat Format>
-void dump_post_function_formatting(const ApiDumpSettings &settings) {
-    if constexpr (Format == ApiDumpFormat::Html) {
+
+inline void dump_post_function_formatting(ApiDumpInstance &api_dump) {
+    auto &settings = api_dump.settings();
+
+    if (settings.format() == ApiDumpFormat::Html) {
         settings.stream() << "</details>";
-    } else if constexpr (Format == ApiDumpFormat::Json) {
+    } else if (settings.format() == ApiDumpFormat::Json) {
         settings.stream() << settings.indentation(2) << "}";
     }
 }
 
 //==================================== Function Head Helpers ======================================//
 
-inline void dump_text_function_head(ApiDumpInstance &dump_inst, const char *funcName, const char *funcNamedParams,
-                                    const char *funcReturn) {
-    const ApiDumpSettings &settings(dump_inst.settings());
-    if (settings.showThreadAndFrame()) {
-        settings.stream() << "Thread " << dump_inst.threadID() << ", Frame " << dump_inst.frameCount();
-    }
-    if (settings.showTimestamp() && settings.showThreadAndFrame()) {
-        settings.stream() << ", ";
-    }
-    if (settings.showTimestamp()) {
-        settings.stream() << "Time " << dump_inst.current_time_since_start().count() << " us";
-    }
-    if (settings.showTimestamp() || settings.showThreadAndFrame()) {
-        settings.stream() << ":\n";
-    }
-    settings.stream() << funcName << "(" << funcNamedParams << ") returns " << funcReturn;
-    if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-        settings.stream() << ":\n";
-    }
-    flush(settings);
-}
-
-inline void dump_html_function_head(ApiDumpInstance &dump_inst, const char *funcName, const char *funcNamedParams,
-                                    const char *funcReturn) {
-    const ApiDumpSettings &settings(dump_inst.settings());
-    if (settings.showThreadAndFrame()) {
-        settings.stream() << "<div class='thd'>Thread: " << dump_inst.threadID() << "</div>";
-    }
-    if (settings.showTimestamp())
-        settings.stream() << "<div class='time'>Time: " << dump_inst.current_time_since_start().count() << " us</div>";
-    settings.stream() << "<details class='fn'><summary>";
-    settings.stream() << "<div class='var'>" << funcName << "(" << funcNamedParams << ")</div>";
-    if (settings.showType()) {
-        settings.stream() << "<div class='type'>" << funcReturn << "</div>";
-    }
-    flush(settings);
-}
-
-inline void dump_json_function_head(ApiDumpInstance &dump_inst, const char *funcName, const char *funcReturn) {
-    const ApiDumpSettings &settings(dump_inst.settings());
-
-    if (!dump_inst.firstFunctionCallOnFrame()) {
-        dump_separate_members<ApiDumpFormat::Json>(settings);
-    }
-    // Display api call name
-    dump_json_start_object(settings, 2);
-    dump_json_key_value(settings, 3, "name", funcName);
+inline void dump_function_head(ApiDumpInstance &api_dump, const char *funcName, const char *funcNamedParams,
+                               const char *funcReturn) {
+    auto &settings = api_dump.settings();
+    switch (api_dump.settings().format()) {
+        case ApiDumpFormat::Text: {
+            if (settings.showThreadAndFrame()) {
+                settings.stream() << "Thread " << api_dump.threadID() << ", Frame " << api_dump.frameCount();
+            }
+            if (settings.showTimestamp() && settings.showThreadAndFrame()) {
+                settings.stream() << ", ";
+            }
+            if (settings.showTimestamp()) {
+                settings.stream() << "Time " << api_dump.current_time_since_start().count() << " us";
+            }
+            if (settings.showTimestamp() || settings.showThreadAndFrame()) {
+                settings.stream() << ":\n";
+            }
+            settings.stream() << funcName << "(" << funcNamedParams << ") returns " << funcReturn;
+            if (settings.shouldPreDump() && api_dump.shouldDumpOutput()) {
+                settings.stream() << ":\n";
+            }
+        }
+        case ApiDumpFormat::Html: {
+            if (settings.showThreadAndFrame()) {
+                settings.stream() << "<div class='thd'>Thread: " << api_dump.threadID() << "</div>";
+            }
+            if (settings.showTimestamp())
+                settings.stream() << "<div class='time'>Time: " << api_dump.current_time_since_start().count() << " us</div>";
+            settings.stream() << "<details class='fn'><summary>";
+            settings.stream() << "<div class='var'>" << funcName << "(" << funcNamedParams << ")</div>";
+            if (settings.showType()) {
+                settings.stream() << "<div class='type'>" << funcReturn << "</div>";
+            }
+        }
+        case ApiDumpFormat::Json: {
+            if (!api_dump.firstFunctionCallOnFrame()) {
+                dump_separate_members(api_dump);
+            }
+            // Display api call name
+            dump_json_start_object(api_dump, 2);
+            dump_json_key_value(api_dump, 3, "name", funcName);
+
+            // Display thread info
+            if (settings.showThreadAndFrame()) {
+                dump_separate_members(api_dump);
+                dump_json_key_value(api_dump, 3, "thread", "Thread ", api_dump.threadID());
+            }
 
-    // Display thread info
-    if (settings.showThreadAndFrame()) {
-        dump_separate_members<ApiDumpFormat::Json>(settings);
-        dump_json_key_value(settings, 3, "thread", "Thread ", dump_inst.threadID());
-    }
+            // Display elapsed time
+            if (settings.showTimestamp()) {
+                dump_separate_members(api_dump);
+                dump_json_key_value(api_dump, 3, "time", api_dump.current_time_since_start().count(), " us");
+            }
 
-    // Display elapsed time
-    if (settings.showTimestamp()) {
-        dump_separate_members<ApiDumpFormat::Json>(settings);
-        dump_json_key_value(settings, 3, "time", dump_inst.current_time_since_start().count(), " us");
+            // Display return type
+            dump_separate_members(api_dump);
+            dump_json_key_value(api_dump, 3, "returnType", funcReturn);
+        }
     }
-
-    // Display return type
-    dump_separate_members<ApiDumpFormat::Json>(settings);
-    dump_json_key_value(settings, 3, "returnType", funcReturn);
-    flush(settings);
+    settings.flush();
 }
 
-inline void dump_json_UNUSED(const ApiDumpSettings &settings, const char *type_string, const char *name, int indents) {
-    dump_json_start_object(settings, indents);
-    dump_json_key_value(settings, indents + 1, "type", type_string);
-    dump_separate_members<ApiDumpFormat::Json>(settings);
-    dump_json_key_value(settings, indents + 1, "name", name);
-    dump_separate_members<ApiDumpFormat::Json>(settings);
-    dump_json_key_value(settings, indents + 1, "address", "UNUSED");
-    dump_separate_members<ApiDumpFormat::Json>(settings);
-    dump_json_key_value(settings, indents + 1, "value", "UNUSED");
-    dump_json_end_object(settings, indents);
-}
-
-//==================================== Common Helpers ======================================//
-
-inline void dump_function_head(ApiDumpInstance &dump_inst, const char *funcName, const char *funcNamedParams,
-                               const char *funcReturn) {
-    if (dump_inst.shouldDumpOutput()) {
-        switch (dump_inst.settings().format()) {
-            case ApiDumpFormat::Text:
-                dump_text_function_head(dump_inst, funcName, funcNamedParams, funcReturn);
-                break;
-            case ApiDumpFormat::Html:
-                dump_html_function_head(dump_inst, funcName, funcNamedParams, funcReturn);
-                break;
-            case ApiDumpFormat::Json:
-                dump_json_function_head(dump_inst, funcName, funcReturn);
-                break;
-        }
-    }
+inline void dump_json_UNUSED(ApiDumpInstance &api_dump, const char *type_string, const char *name, int indents) {
+    dump_json_start_object(api_dump, indents);
+    dump_json_key_value(api_dump, indents + 1, "type", type_string);
+    dump_separate_members(api_dump);
+    dump_json_key_value(api_dump, indents + 1, "name", name);
+    dump_separate_members(api_dump);
+    dump_json_key_value(api_dump, indents + 1, "address", "UNUSED");
+    dump_separate_members(api_dump);
+    dump_json_key_value(api_dump, indents + 1, "value", "UNUSED");
+    dump_json_end_object(api_dump, indents);
 }
diff --git a/layersvt/api_dump_handwritten_dispatch.cpp b/layersvt/api_dump_handwritten_dispatch.cpp
index 94363930e9..3640ebb478 100644
--- a/layersvt/api_dump_handwritten_dispatch.cpp
+++ b/layersvt/api_dump_handwritten_dispatch.cpp
@@ -31,31 +31,12 @@ extern "C" {
 
 EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
     PFN_vkVoidFunction instance_func = nullptr;
-    switch (ApiDumpInstance::current().settings().format()) {
-        case ApiDumpFormat::Text:
-            instance_func = api_dump_known_instance_functions<ApiDumpFormat::Text>(instance, pName);
-            break;
-        case ApiDumpFormat::Html:
-            instance_func = api_dump_known_instance_functions<ApiDumpFormat::Html>(instance, pName);
-            break;
-        case ApiDumpFormat::Json:
-            instance_func = api_dump_known_instance_functions<ApiDumpFormat::Json>(instance, pName);
-            break;
-    }
+    instance_func = api_dump_known_instance_functions(instance, pName);
     if (instance_func) return instance_func;
     PFN_vkVoidFunction device_func = nullptr;
 
-    switch (ApiDumpInstance::current().settings().format()) {
-        case ApiDumpFormat::Text:
-            device_func = api_dump_known_device_functions<ApiDumpFormat::Text>(NULL, pName);
-            break;
-        case ApiDumpFormat::Html:
-            device_func = api_dump_known_device_functions<ApiDumpFormat::Html>(NULL, pName);
-            break;
-        case ApiDumpFormat::Json:
-            device_func = api_dump_known_device_functions<ApiDumpFormat::Json>(NULL, pName);
-            break;
-    }
+    device_func = api_dump_known_device_functions(NULL, pName);
+
     // Make sure that device functions queried through GIPA works
     if (device_func) return device_func;
 
@@ -66,17 +47,9 @@ EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(V
 
 EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* pName) {
     PFN_vkVoidFunction device_func = nullptr;
-    switch (ApiDumpInstance::current().settings().format()) {
-        case ApiDumpFormat::Text:
-            device_func = api_dump_known_device_functions<ApiDumpFormat::Text>(device, pName);
-            break;
-        case ApiDumpFormat::Html:
-            device_func = api_dump_known_device_functions<ApiDumpFormat::Html>(device, pName);
-            break;
-        case ApiDumpFormat::Json:
-            device_func = api_dump_known_device_functions<ApiDumpFormat::Json>(device, pName);
-            break;
-    }
+
+    device_func = api_dump_known_device_functions(device, pName);
+
     if (device_func) return device_func;
 
     // Haven't created a device yet, exit now since there is no device_dispatch_table
diff --git a/layersvt/api_dump_handwritten_functions.h b/layersvt/api_dump_handwritten_functions.h
index 2dabffd8d9..5b8e400f42 100644
--- a/layersvt/api_dump_handwritten_functions.h
+++ b/layersvt/api_dump_handwritten_functions.h
@@ -42,14 +42,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCre
     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 #endif
-
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    ApiDumpInstance::current().initLayerSettings(pCreateInfo, pAllocator);
-    dump_function_head(ApiDumpInstance::current(), "vkCreateInstance", "pCreateInfo, pAllocator, pInstance", "VkResult");
-    if (ApiDumpInstance::current().settings().shouldPreDump() &&
-        ApiDumpInstance::current().settings().format() == ApiDumpFormat::Text && ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_before_pre_dump_formatting<ApiDumpFormat::Text>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateInstance<ApiDumpFormat::Text>(ApiDumpInstance::current(), pCreateInfo, pAllocator, pInstance);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    api_dump.initLayerSettings(pCreateInfo, pAllocator);
+    dump_function_head(api_dump, "vkCreateInstance", "pCreateInfo, pAllocator, pInstance", "VkResult");
+    if (api_dump.settings().shouldPreDump() && api_dump.settings().format() == ApiDumpFormat::Text && api_dump.shouldDumpOutput()) {
+        dump_before_pre_dump_formatting(api_dump);
+        dump_params_vkCreateInstance(api_dump, pCreateInfo, pAllocator, pInstance);
     }
 
     // Get the function pointer
@@ -70,48 +69,27 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCre
     }
 
     // Output the API dump
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        switch (ApiDumpInstance::current().settings().format()) {
-            case ApiDumpFormat::Text:
-                dump_return_value<ApiDumpFormat::Text>(ApiDumpInstance::current().settings(), "VkResult", result,
-                                                       dump_return_value_VkResult<ApiDumpFormat::Text>);
-                dump_pre_function_formatting<ApiDumpFormat::Text>(ApiDumpInstance::current().settings());
-                dump_params_vkCreateInstance<ApiDumpFormat::Text>(ApiDumpInstance::current(), pCreateInfo, pAllocator, pInstance);
-                dump_post_function_formatting<ApiDumpFormat::Text>(ApiDumpInstance::current().settings());
-                break;
-            case ApiDumpFormat::Html:
-                dump_return_value<ApiDumpFormat::Html>(ApiDumpInstance::current().settings(), "VkResult", result,
-                                                       dump_return_value_VkResult<ApiDumpFormat::Html>);
-                dump_pre_function_formatting<ApiDumpFormat::Html>(ApiDumpInstance::current().settings());
-                dump_params_vkCreateInstance<ApiDumpFormat::Html>(ApiDumpInstance::current(), pCreateInfo, pAllocator, pInstance);
-                dump_post_function_formatting<ApiDumpFormat::Html>(ApiDumpInstance::current().settings());
-                break;
-            case ApiDumpFormat::Json:
-                dump_return_value<ApiDumpFormat::Json>(ApiDumpInstance::current().settings(), "VkResult", result,
-                                                       dump_return_value_VkResult<ApiDumpFormat::Json>);
-                dump_pre_function_formatting<ApiDumpFormat::Json>(ApiDumpInstance::current().settings());
-                dump_params_vkCreateInstance<ApiDumpFormat::Json>(ApiDumpInstance::current(), pCreateInfo, pAllocator, pInstance);
-                dump_post_function_formatting<ApiDumpFormat::Json>(ApiDumpInstance::current().settings());
-                break;
-        }
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateInstance(api_dump, pCreateInfo, pAllocator, pInstance);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 
     return result;
 }
 }
 
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
                                               const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDevice", "physicalDevice, pCreateInfo, pAllocator, pDevice",
-                       "VkResult");
-    if (ApiDumpInstance::current().settings().shouldPreDump() &&
-        ApiDumpInstance::current().settings().format() == ApiDumpFormat::Text && ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_before_pre_dump_formatting<ApiDumpFormat::Text>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDevice<ApiDumpFormat::Text>(ApiDumpInstance::current(), physicalDevice, pCreateInfo, pAllocator,
-                                                        pDevice);
+    auto& api_dump = ApiDumpInstance::current();
+
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateDevice", "physicalDevice, pCreateInfo, pAllocator, pDevice", "VkResult");
+    if (api_dump.settings().shouldPreDump() && api_dump.settings().format() == ApiDumpFormat::Text && api_dump.shouldDumpOutput()) {
+        dump_before_pre_dump_formatting(api_dump);
+        dump_params_vkCreateDevice(api_dump, physicalDevice, pCreateInfo, pAllocator, pDevice);
     }
 
     // Get the function pointer
@@ -119,7 +97,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, c
     assert(chain_info->u.pLayerInfo != 0);
     PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
     PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
-    VkInstance vk_instance = ApiDumpInstance::current().get_vk_instance(physicalDevice);
+    VkInstance vk_instance = api_dump.get_vk_instance(physicalDevice);
     PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(vk_instance, "vkCreateDevice");
     if (fpCreateDevice == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
@@ -133,13 +111,12 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, c
     }
 
     // Output the API dump
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDevice<Format>(ApiDumpInstance::current(), physicalDevice, pCreateInfo, pAllocator, pDevice);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDevice(api_dump, physicalDevice, pCreateInfo, pAllocator, pDevice);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
diff --git a/layersvt/generated/api_dump_dispatch.h b/layersvt/generated/api_dump_dispatch.h
index 72551aa286..cf5e3d6048 100644
--- a/layersvt/generated/api_dump_dispatch.h
+++ b/layersvt/generated/api_dump_dispatch.h
@@ -25,1742 +25,1742 @@
 
 // Autogen instance functions
 
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyInstance", "instance, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyInstance<Format>(ApiDumpInstance::current(), instance, pAllocator);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkDestroyInstance", "instance, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyInstance(api_dump, instance, pAllocator);
         }
     }
     auto dispatch_key = get_dispatch_key(instance);
     instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator);
     destroy_instance_dispatch_table(dispatch_key);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyInstance<Format>(ApiDumpInstance::current(), instance, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyInstance(api_dump, instance, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDevices", "instance, pPhysicalDeviceCount, pPhysicalDevices", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkEnumeratePhysicalDevices<Format>(ApiDumpInstance::current(), instance, pPhysicalDeviceCount, pPhysicalDevices);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkEnumeratePhysicalDevices", "instance, pPhysicalDeviceCount, pPhysicalDevices", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkEnumeratePhysicalDevices(api_dump, instance, pPhysicalDeviceCount, pPhysicalDevices);
         }
     }
     VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
 
     if (pPhysicalDeviceCount != nullptr && pPhysicalDevices != nullptr) {
         for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
-            ApiDumpInstance::current().set_vk_instance(pPhysicalDevices[i], instance);
+            api_dump.set_vk_instance(pPhysicalDevices[i], instance);
         }
     }
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkEnumeratePhysicalDevices<Format>(ApiDumpInstance::current(), instance, pPhysicalDeviceCount, pPhysicalDevices);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkEnumeratePhysicalDevices(api_dump, instance, pPhysicalDeviceCount, pPhysicalDevices);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFeatures", "physicalDevice, pFeatures", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFeatures<Format>(ApiDumpInstance::current(), physicalDevice, pFeatures);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFeatures", "physicalDevice, pFeatures", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFeatures(api_dump, physicalDevice, pFeatures);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFeatures<Format>(ApiDumpInstance::current(), physicalDevice, pFeatures);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFeatures(api_dump, physicalDevice, pFeatures);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFormatProperties", "physicalDevice, format, pFormatProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFormatProperties<Format>(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFormatProperties", "physicalDevice, format, pFormatProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFormatProperties(api_dump, physicalDevice, format, pFormatProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFormatProperties<Format>(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFormatProperties(api_dump, physicalDevice, format, pFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceImageFormatProperties", "physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceImageFormatProperties<Format>(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceImageFormatProperties", "physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceImageFormatProperties(api_dump, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceImageFormatProperties<Format>(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceImageFormatProperties(api_dump, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceProperties", "physicalDevice, pProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceProperties<Format>(ApiDumpInstance::current(), physicalDevice, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceProperties", "physicalDevice, pProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceProperties(api_dump, physicalDevice, pProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceProperties<Format>(ApiDumpInstance::current(), physicalDevice, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceProperties(api_dump, physicalDevice, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyProperties", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceQueueFamilyProperties<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceQueueFamilyProperties", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceQueueFamilyProperties(api_dump, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceQueueFamilyProperties<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceQueueFamilyProperties(api_dump, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMemoryProperties", "physicalDevice, pMemoryProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceMemoryProperties<Format>(ApiDumpInstance::current(), physicalDevice, pMemoryProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceMemoryProperties", "physicalDevice, pMemoryProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceMemoryProperties(api_dump, physicalDevice, pMemoryProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceMemoryProperties<Format>(ApiDumpInstance::current(), physicalDevice, pMemoryProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceMemoryProperties(api_dump, physicalDevice, pMemoryProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSparseImageFormatProperties", "physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSparseImageFormatProperties<Format>(ApiDumpInstance::current(), physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSparseImageFormatProperties", "physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(api_dump, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSparseImageFormatProperties<Format>(ApiDumpInstance::current(), physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(api_dump, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceGroups", "instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkEnumeratePhysicalDeviceGroups<Format>(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkEnumeratePhysicalDeviceGroups", "instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkEnumeratePhysicalDeviceGroups(api_dump, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
         }
     }
     VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkEnumeratePhysicalDeviceGroups<Format>(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkEnumeratePhysicalDeviceGroups(api_dump, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFeatures2", "physicalDevice, pFeatures", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFeatures2<Format>(ApiDumpInstance::current(), physicalDevice, pFeatures);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFeatures2", "physicalDevice, pFeatures", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFeatures2(api_dump, physicalDevice, pFeatures);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFeatures2<Format>(ApiDumpInstance::current(), physicalDevice, pFeatures);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFeatures2(api_dump, physicalDevice, pFeatures);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceProperties2", "physicalDevice, pProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceProperties2", "physicalDevice, pProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceProperties2(api_dump, physicalDevice, pProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2(physicalDevice, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceProperties2(api_dump, physicalDevice, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFormatProperties2", "physicalDevice, format, pFormatProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFormatProperties2<Format>(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFormatProperties2", "physicalDevice, format, pFormatProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFormatProperties2(api_dump, physicalDevice, format, pFormatProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFormatProperties2<Format>(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFormatProperties2(api_dump, physicalDevice, format, pFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceImageFormatProperties2", "physicalDevice, pImageFormatInfo, pImageFormatProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceImageFormatProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceImageFormatProperties2", "physicalDevice, pImageFormatInfo, pImageFormatProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceImageFormatProperties2(api_dump, physicalDevice, pImageFormatInfo, pImageFormatProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceImageFormatProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceImageFormatProperties2(api_dump, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyProperties2", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceQueueFamilyProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceQueueFamilyProperties2", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(api_dump, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceQueueFamilyProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(api_dump, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMemoryProperties2", "physicalDevice, pMemoryProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceMemoryProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pMemoryProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceMemoryProperties2", "physicalDevice, pMemoryProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceMemoryProperties2(api_dump, physicalDevice, pMemoryProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceMemoryProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pMemoryProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceMemoryProperties2(api_dump, physicalDevice, pMemoryProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSparseImageFormatProperties2", "physicalDevice, pFormatInfo, pPropertyCount, pProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSparseImageFormatProperties2", "physicalDevice, pFormatInfo, pPropertyCount, pProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(api_dump, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2<Format>(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(api_dump, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalBufferProperties", "physicalDevice, pExternalBufferInfo, pExternalBufferProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalBufferProperties<Format>(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalBufferProperties", "physicalDevice, pExternalBufferInfo, pExternalBufferProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalBufferProperties(api_dump, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalBufferProperties<Format>(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalBufferProperties(api_dump, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalFenceProperties", "physicalDevice, pExternalFenceInfo, pExternalFenceProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalFenceProperties<Format>(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalFenceProperties", "physicalDevice, pExternalFenceInfo, pExternalFenceProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalFenceProperties(api_dump, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalFenceProperties<Format>(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalFenceProperties(api_dump, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalSemaphoreProperties", "physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties<Format>(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalSemaphoreProperties", "physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(api_dump, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties<Format>(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(api_dump, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceToolProperties", "physicalDevice, pToolCount, pToolProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceToolProperties<Format>(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceToolProperties", "physicalDevice, pToolCount, pToolProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceToolProperties(api_dump, physicalDevice, pToolCount, pToolProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceToolProperties<Format>(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceToolProperties(api_dump, physicalDevice, pToolCount, pToolProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkDestroySurfaceKHR", "instance, surface, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroySurfaceKHR<Format>(ApiDumpInstance::current(), instance, surface, pAllocator);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkDestroySurfaceKHR", "instance, surface, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroySurfaceKHR(api_dump, instance, surface, pAllocator);
         }
     }
     instance_dispatch_table(instance)->DestroySurfaceKHR(instance, surface, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroySurfaceKHR<Format>(ApiDumpInstance::current(), instance, surface, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroySurfaceKHR(api_dump, instance, surface, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceSupportKHR", "physicalDevice, queueFamilyIndex, surface, pSupported", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfaceSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, surface, pSupported);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfaceSupportKHR", "physicalDevice, queueFamilyIndex, surface, pSupported", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(api_dump, physicalDevice, queueFamilyIndex, surface, pSupported);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfaceSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, surface, pSupported);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(api_dump, physicalDevice, queueFamilyIndex, surface, pSupported);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "physicalDevice, surface, pSurfaceCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "physicalDevice, surface, pSurfaceCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(api_dump, physicalDevice, surface, pSurfaceCapabilities);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(api_dump, physicalDevice, surface, pSurfaceCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceFormatsKHR", "physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfaceFormatsKHR", "physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(api_dump, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(api_dump, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfacePresentModesKHR", "physicalDevice, surface, pPresentModeCount, pPresentModes", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pPresentModeCount, pPresentModes);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfacePresentModesKHR", "physicalDevice, surface, pPresentModeCount, pPresentModes", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(api_dump, physicalDevice, surface, pPresentModeCount, pPresentModes);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pPresentModeCount, pPresentModes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(api_dump, physicalDevice, surface, pPresentModeCount, pPresentModes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDevicePresentRectanglesKHR", "physicalDevice, surface, pRectCount, pRects", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDevicePresentRectanglesKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pRectCount, pRects);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDevicePresentRectanglesKHR", "physicalDevice, surface, pRectCount, pRects", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDevicePresentRectanglesKHR(api_dump, physicalDevice, surface, pRectCount, pRects);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDevicePresentRectanglesKHR<Format>(ApiDumpInstance::current(), physicalDevice, surface, pRectCount, pRects);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDevicePresentRectanglesKHR(api_dump, physicalDevice, surface, pRectCount, pRects);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayPropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceDisplayPropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetDisplayPlaneSupportedDisplaysKHR", "physicalDevice, planeIndex, pDisplayCount, pDisplays", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDisplayPlaneSupportedDisplaysKHR<Format>(ApiDumpInstance::current(), physicalDevice, planeIndex, pDisplayCount, pDisplays);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetDisplayPlaneSupportedDisplaysKHR", "physicalDevice, planeIndex, pDisplayCount, pDisplays", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(api_dump, physicalDevice, planeIndex, pDisplayCount, pDisplays);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDisplayPlaneSupportedDisplaysKHR<Format>(ApiDumpInstance::current(), physicalDevice, planeIndex, pDisplayCount, pDisplays);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(api_dump, physicalDevice, planeIndex, pDisplayCount, pDisplays);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetDisplayModePropertiesKHR", "physicalDevice, display, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDisplayModePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetDisplayModePropertiesKHR", "physicalDevice, display, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDisplayModePropertiesKHR(api_dump, physicalDevice, display, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDisplayModePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDisplayModePropertiesKHR(api_dump, physicalDevice, display, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDisplayModeKHR", "physicalDevice, display, pCreateInfo, pAllocator, pMode", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDisplayModeKHR<Format>(ApiDumpInstance::current(), physicalDevice, display, pCreateInfo, pAllocator, pMode);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateDisplayModeKHR", "physicalDevice, display, pCreateInfo, pAllocator, pMode", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDisplayModeKHR(api_dump, physicalDevice, display, pCreateInfo, pAllocator, pMode);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDisplayModeKHR<Format>(ApiDumpInstance::current(), physicalDevice, display, pCreateInfo, pAllocator, pMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDisplayModeKHR(api_dump, physicalDevice, display, pCreateInfo, pAllocator, pMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetDisplayPlaneCapabilitiesKHR", "physicalDevice, mode, planeIndex, pCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDisplayPlaneCapabilitiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, mode, planeIndex, pCapabilities);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetDisplayPlaneCapabilitiesKHR", "physicalDevice, mode, planeIndex, pCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDisplayPlaneCapabilitiesKHR(api_dump, physicalDevice, mode, planeIndex, pCapabilities);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDisplayPlaneCapabilitiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, mode, planeIndex, pCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDisplayPlaneCapabilitiesKHR(api_dump, physicalDevice, mode, planeIndex, pCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDisplayPlaneSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDisplayPlaneSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateDisplayPlaneSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDisplayPlaneSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDisplayPlaneSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDisplayPlaneSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateXlibSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateXlibSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateXlibSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateXlibSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateXlibSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateXlibSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceXlibPresentationSupportKHR", "physicalDevice, queueFamilyIndex, dpy, visualID", "VkBool32");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dpy, visualID);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceXlibPresentationSupportKHR", "physicalDevice, queueFamilyIndex, dpy, visualID", "VkBool32");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex, dpy, visualID);
         }
     }
     VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkBool32", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dpy, visualID);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkBool32", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex, dpy, visualID);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_XLIB_KHR
 #if defined(VK_USE_PLATFORM_XCB_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateXcbSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateXcbSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateXcbSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateXcbSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateXcbSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateXcbSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceXcbPresentationSupportKHR", "physicalDevice, queueFamilyIndex, connection, visual_id", "VkBool32");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, connection, visual_id);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceXcbPresentationSupportKHR", "physicalDevice, queueFamilyIndex, connection, visual_id", "VkBool32");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex, connection, visual_id);
         }
     }
     VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkBool32", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, connection, visual_id);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkBool32", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex, connection, visual_id);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_XCB_KHR
 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateWaylandSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateWaylandSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateWaylandSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateWaylandSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateWaylandSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateWaylandSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "physicalDevice, queueFamilyIndex, display", "VkBool32");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, display);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "physicalDevice, queueFamilyIndex, display", "VkBool32");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex, display);
         }
     }
     VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkBool32", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, display);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkBool32", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex, display);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateAndroidSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateAndroidSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateAndroidSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateAndroidSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateAndroidSurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateAndroidSurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateWin32SurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateWin32SurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateWin32SurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateWin32SurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateWin32SurfaceKHR<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateWin32SurfaceKHR(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceWin32PresentationSupportKHR", "physicalDevice, queueFamilyIndex", "VkBool32");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceWin32PresentationSupportKHR", "physicalDevice, queueFamilyIndex", "VkBool32");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex);
         }
     }
     VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkBool32", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkBool32", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(api_dump, physicalDevice, queueFamilyIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceVideoCapabilitiesKHR", "physicalDevice, pVideoProfile, pCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pVideoProfile, pCapabilities);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceVideoCapabilitiesKHR", "physicalDevice, pVideoProfile, pCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(api_dump, physicalDevice, pVideoProfile, pCapabilities);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pVideoProfile, pCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(api_dump, physicalDevice, pVideoProfile, pCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceVideoFormatPropertiesKHR", "physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceVideoFormatPropertiesKHR", "physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(api_dump, physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(api_dump, physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFeatures2KHR", "physicalDevice, pFeatures", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFeatures2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pFeatures);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFeatures2KHR", "physicalDevice, pFeatures", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFeatures2KHR(api_dump, physicalDevice, pFeatures);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFeatures2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pFeatures);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFeatures2KHR(api_dump, physicalDevice, pFeatures);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceProperties2KHR", "physicalDevice, pProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceProperties2KHR", "physicalDevice, pProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceProperties2KHR(api_dump, physicalDevice, pProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceProperties2KHR(api_dump, physicalDevice, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFormatProperties2KHR", "physicalDevice, format, pFormatProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFormatProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFormatProperties2KHR", "physicalDevice, format, pFormatProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFormatProperties2KHR(api_dump, physicalDevice, format, pFormatProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFormatProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFormatProperties2KHR(api_dump, physicalDevice, format, pFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceImageFormatProperties2KHR", "physicalDevice, pImageFormatInfo, pImageFormatProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceImageFormatProperties2KHR", "physicalDevice, pImageFormatInfo, pImageFormatProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(api_dump, physicalDevice, pImageFormatInfo, pImageFormatProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(api_dump, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyProperties2KHR", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceQueueFamilyProperties2KHR", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(api_dump, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(api_dump, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMemoryProperties2KHR", "physicalDevice, pMemoryProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceMemoryProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pMemoryProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceMemoryProperties2KHR", "physicalDevice, pMemoryProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(api_dump, physicalDevice, pMemoryProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceMemoryProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pMemoryProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(api_dump, physicalDevice, pMemoryProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "physicalDevice, pFormatInfo, pPropertyCount, pProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "physicalDevice, pFormatInfo, pPropertyCount, pProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(api_dump, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(api_dump, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceGroupsKHR", "instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkEnumeratePhysicalDeviceGroupsKHR<Format>(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkEnumeratePhysicalDeviceGroupsKHR", "instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkEnumeratePhysicalDeviceGroupsKHR(api_dump, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
         }
     }
     VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkEnumeratePhysicalDeviceGroupsKHR<Format>(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkEnumeratePhysicalDeviceGroupsKHR(api_dump, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "physicalDevice, pExternalBufferInfo, pExternalBufferProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "physicalDevice, pExternalBufferInfo, pExternalBufferProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(api_dump, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(api_dump, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(api_dump, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(api_dump, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalFencePropertiesKHR", "physicalDevice, pExternalFenceInfo, pExternalFenceProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalFencePropertiesKHR", "physicalDevice, pExternalFenceInfo, pExternalFenceProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(api_dump, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(api_dump, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", "physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", "physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(api_dump, physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(api_dump, physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", "physicalDevice, pPerformanceQueryCreateInfo, pNumPasses", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", "physicalDevice, pPerformanceQueryCreateInfo, pNumPasses", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(api_dump, physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(api_dump, physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "physicalDevice, pSurfaceInfo, pSurfaceCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "physicalDevice, pSurfaceInfo, pSurfaceCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(api_dump, physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(api_dump, physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceFormats2KHR", "physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfaceFormats2KHR", "physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(api_dump, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(api_dump, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayProperties2KHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceDisplayProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceDisplayProperties2KHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceDisplayProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayPlaneProperties2KHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetDisplayModeProperties2KHR", "physicalDevice, display, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDisplayModeProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetDisplayModeProperties2KHR", "physicalDevice, display, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDisplayModeProperties2KHR(api_dump, physicalDevice, display, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDisplayModeProperties2KHR<Format>(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDisplayModeProperties2KHR(api_dump, physicalDevice, display, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetDisplayPlaneCapabilities2KHR", "physicalDevice, pDisplayPlaneInfo, pCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDisplayPlaneCapabilities2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pDisplayPlaneInfo, pCapabilities);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetDisplayPlaneCapabilities2KHR", "physicalDevice, pDisplayPlaneInfo, pCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDisplayPlaneCapabilities2KHR(api_dump, physicalDevice, pDisplayPlaneInfo, pCapabilities);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDisplayPlaneCapabilities2KHR<Format>(ApiDumpInstance::current(), physicalDevice, pDisplayPlaneInfo, pCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDisplayPlaneCapabilities2KHR(api_dump, physicalDevice, pDisplayPlaneInfo, pCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFragmentShadingRatesKHR", "physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceFragmentShadingRatesKHR", "physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(api_dump, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(api_dump, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", "physicalDevice, pQualityLevelInfo, pQualityLevelProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pQualityLevelInfo, pQualityLevelProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", "physicalDevice, pQualityLevelInfo, pQualityLevelProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(api_dump, physicalDevice, pQualityLevelInfo, pQualityLevelProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pQualityLevelInfo, pQualityLevelProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(api_dump, physicalDevice, pQualityLevelInfo, pQualityLevelProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", "physicalDevice, pTimeDomainCount, pTimeDomains", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR<Format>(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", "physicalDevice, pTimeDomainCount, pTimeDomains", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(api_dump, physicalDevice, pTimeDomainCount, pTimeDomains);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR<Format>(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(api_dump, physicalDevice, pTimeDomainCount, pTimeDomains);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDebugReportCallbackEXT", "instance, pCreateInfo, pAllocator, pCallback", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDebugReportCallbackEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pCallback);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateDebugReportCallbackEXT", "instance, pCreateInfo, pAllocator, pCallback", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDebugReportCallbackEXT(api_dump, instance, pCreateInfo, pAllocator, pCallback);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDebugReportCallbackEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pCallback);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDebugReportCallbackEXT(api_dump, instance, pCreateInfo, pAllocator, pCallback);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDebugReportCallbackEXT", "instance, callback, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDebugReportCallbackEXT<Format>(ApiDumpInstance::current(), instance, callback, pAllocator);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkDestroyDebugReportCallbackEXT", "instance, callback, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDebugReportCallbackEXT(api_dump, instance, callback, pAllocator);
         }
     }
     instance_dispatch_table(instance)->DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDebugReportCallbackEXT<Format>(ApiDumpInstance::current(), instance, callback, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDebugReportCallbackEXT(api_dump, instance, callback, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkDebugReportMessageEXT", "instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDebugReportMessageEXT<Format>(ApiDumpInstance::current(), instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkDebugReportMessageEXT", "instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDebugReportMessageEXT(api_dump, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
         }
     }
     instance_dispatch_table(instance)->DebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDebugReportMessageEXT<Format>(ApiDumpInstance::current(), instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDebugReportMessageEXT(api_dump, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_GGP)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateStreamDescriptorSurfaceGGP", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateStreamDescriptorSurfaceGGP<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateStreamDescriptorSurfaceGGP", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateStreamDescriptorSurfaceGGP(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateStreamDescriptorSurfaceGGP<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateStreamDescriptorSurfaceGGP(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_GGP
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(api_dump, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(api_dump, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_VI_NN)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateViSurfaceNN", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateViSurfaceNN<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateViSurfaceNN", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateViSurfaceNN(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateViSurfaceNN<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateViSurfaceNN(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_VI_NN
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkReleaseDisplayEXT", "physicalDevice, display", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleaseDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, display);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkReleaseDisplayEXT", "physicalDevice, display", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleaseDisplayEXT(api_dump, physicalDevice, display);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->ReleaseDisplayEXT(physicalDevice, display);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleaseDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, display);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleaseDisplayEXT(api_dump, physicalDevice, display);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireXlibDisplayEXT", "physicalDevice, dpy, display", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquireXlibDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, dpy, display);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkAcquireXlibDisplayEXT", "physicalDevice, dpy, display", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquireXlibDisplayEXT(api_dump, physicalDevice, dpy, display);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireXlibDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, dpy, display);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireXlibDisplayEXT(api_dump, physicalDevice, dpy, display);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetRandROutputDisplayEXT", "physicalDevice, dpy, rrOutput, pDisplay", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRandROutputDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, dpy, rrOutput, pDisplay);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetRandROutputDisplayEXT", "physicalDevice, dpy, rrOutput, pDisplay", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRandROutputDisplayEXT(api_dump, physicalDevice, dpy, rrOutput, pDisplay);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRandROutputDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, dpy, rrOutput, pDisplay);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRandROutputDisplayEXT(api_dump, physicalDevice, dpy, rrOutput, pDisplay);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceCapabilities2EXT", "physicalDevice, surface, pSurfaceCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT<Format>(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", "physicalDevice, surface, pSurfaceCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(api_dump, physicalDevice, surface, pSurfaceCapabilities);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT<Format>(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(api_dump, physicalDevice, surface, pSurfaceCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_IOS_MVK)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateIOSSurfaceMVK", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateIOSSurfaceMVK<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateIOSSurfaceMVK", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateIOSSurfaceMVK(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateIOSSurfaceMVK<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateIOSSurfaceMVK(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_IOS_MVK
 #if defined(VK_USE_PLATFORM_MACOS_MVK)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateMacOSSurfaceMVK", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateMacOSSurfaceMVK<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateMacOSSurfaceMVK", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateMacOSSurfaceMVK(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateMacOSSurfaceMVK<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateMacOSSurfaceMVK(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_MACOS_MVK
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDebugUtilsMessengerEXT", "instance, pCreateInfo, pAllocator, pMessenger", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDebugUtilsMessengerEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pMessenger);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateDebugUtilsMessengerEXT", "instance, pCreateInfo, pAllocator, pMessenger", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDebugUtilsMessengerEXT(api_dump, instance, pCreateInfo, pAllocator, pMessenger);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDebugUtilsMessengerEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pMessenger);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDebugUtilsMessengerEXT(api_dump, instance, pCreateInfo, pAllocator, pMessenger);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDebugUtilsMessengerEXT", "instance, messenger, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDebugUtilsMessengerEXT<Format>(ApiDumpInstance::current(), instance, messenger, pAllocator);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkDestroyDebugUtilsMessengerEXT", "instance, messenger, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDebugUtilsMessengerEXT(api_dump, instance, messenger, pAllocator);
         }
     }
     instance_dispatch_table(instance)->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDebugUtilsMessengerEXT<Format>(ApiDumpInstance::current(), instance, messenger, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDebugUtilsMessengerEXT(api_dump, instance, messenger, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkSubmitDebugUtilsMessageEXT", "instance, messageSeverity, messageTypes, pCallbackData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSubmitDebugUtilsMessageEXT<Format>(ApiDumpInstance::current(), instance, messageSeverity, messageTypes, pCallbackData);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkSubmitDebugUtilsMessageEXT", "instance, messageSeverity, messageTypes, pCallbackData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSubmitDebugUtilsMessageEXT(api_dump, instance, messageSeverity, messageTypes, pCallbackData);
         }
     }
     instance_dispatch_table(instance)->SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSubmitDebugUtilsMessageEXT<Format>(ApiDumpInstance::current(), instance, messageSeverity, messageTypes, pCallbackData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSubmitDebugUtilsMessageEXT(api_dump, instance, messageSeverity, messageTypes, pCallbackData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDescriptorSizeEXT", "physicalDevice, descriptorType", "VkDeviceSize");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceDescriptorSizeEXT<Format>(ApiDumpInstance::current(), physicalDevice, descriptorType);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceDescriptorSizeEXT", "physicalDevice, descriptorType", "VkDeviceSize");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(api_dump, physicalDevice, descriptorType);
         }
     }
     VkDeviceSize result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDescriptorSizeEXT(physicalDevice, descriptorType);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceSize", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceDescriptorSizeEXT<Format>(ApiDumpInstance::current(), physicalDevice, descriptorType);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceSize", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(api_dump, physicalDevice, descriptorType);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMultisamplePropertiesEXT", "physicalDevice, samples, pMultisampleProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT<Format>(ApiDumpInstance::current(), physicalDevice, samples, pMultisampleProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceMultisamplePropertiesEXT", "physicalDevice, samples, pMultisampleProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(api_dump, physicalDevice, samples, pMultisampleProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT<Format>(ApiDumpInstance::current(), physicalDevice, samples, pMultisampleProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(api_dump, physicalDevice, samples, pMultisampleProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", "physicalDevice, pTimeDomainCount, pTimeDomains", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT<Format>(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", "physicalDevice, pTimeDomainCount, pTimeDomains", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(api_dump, physicalDevice, pTimeDomainCount, pTimeDomains);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT<Format>(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(api_dump, physicalDevice, pTimeDomainCount, pTimeDomains);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_FUCHSIA)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateImagePipeSurfaceFUCHSIA", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateImagePipeSurfaceFUCHSIA<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateImagePipeSurfaceFUCHSIA", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateImagePipeSurfaceFUCHSIA(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateImagePipeSurfaceFUCHSIA<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateImagePipeSurfaceFUCHSIA(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_FUCHSIA
 #if defined(VK_USE_PLATFORM_METAL_EXT)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateMetalSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateMetalSurfaceEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateMetalSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateMetalSurfaceEXT(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateMetalSurfaceEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateMetalSurfaceEXT(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_METAL_EXT
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceToolPropertiesEXT", "physicalDevice, pToolCount, pToolProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceToolPropertiesEXT<Format>(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceToolPropertiesEXT", "physicalDevice, pToolCount, pToolProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceToolPropertiesEXT(api_dump, physicalDevice, pToolCount, pToolProperties);
         }
     }
 
@@ -1785,13591 +1785,13589 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDe
     }
 
     (*pToolCount)++;
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceToolPropertiesEXT<Format>(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceToolPropertiesEXT(api_dump, physicalDevice, pToolCount, pToolProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", "physicalDevice, pCombinationCount, pCombinations", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV<Format>(ApiDumpInstance::current(), physicalDevice, pCombinationCount, pCombinations);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", "physicalDevice, pCombinationCount, pCombinations", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(api_dump, physicalDevice, pCombinationCount, pCombinations);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV<Format>(ApiDumpInstance::current(), physicalDevice, pCombinationCount, pCombinations);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(api_dump, physicalDevice, pCombinationCount, pCombinations);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfacePresentModes2EXT", "physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT<Format>(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceSurfacePresentModes2EXT", "physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(api_dump, physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT<Format>(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(api_dump, physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateHeadlessSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateHeadlessSurfaceEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateHeadlessSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateHeadlessSurfaceEXT(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateHeadlessSurfaceEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateHeadlessSurfaceEXT(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireDrmDisplayEXT", "physicalDevice, drmFd, display", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquireDrmDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, drmFd, display);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkAcquireDrmDisplayEXT", "physicalDevice, drmFd, display", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquireDrmDisplayEXT(api_dump, physicalDevice, drmFd, display);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->AcquireDrmDisplayEXT(physicalDevice, drmFd, display);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireDrmDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, drmFd, display);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireDrmDisplayEXT(api_dump, physicalDevice, drmFd, display);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetDrmDisplayEXT", "physicalDevice, drmFd, connectorId, display", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDrmDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, drmFd, connectorId, display);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetDrmDisplayEXT", "physicalDevice, drmFd, connectorId, display", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDrmDisplayEXT(api_dump, physicalDevice, drmFd, connectorId, display);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDrmDisplayEXT<Format>(ApiDumpInstance::current(), physicalDevice, drmFd, connectorId, display);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDrmDisplayEXT(api_dump, physicalDevice, drmFd, connectorId, display);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireWinrtDisplayNV", "physicalDevice, display", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquireWinrtDisplayNV<Format>(ApiDumpInstance::current(), physicalDevice, display);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkAcquireWinrtDisplayNV", "physicalDevice, display", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquireWinrtDisplayNV(api_dump, physicalDevice, display);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->AcquireWinrtDisplayNV(physicalDevice, display);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireWinrtDisplayNV<Format>(ApiDumpInstance::current(), physicalDevice, display);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireWinrtDisplayNV(api_dump, physicalDevice, display);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetWinrtDisplayNV", "physicalDevice, deviceRelativeId, pDisplay", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetWinrtDisplayNV<Format>(ApiDumpInstance::current(), physicalDevice, deviceRelativeId, pDisplay);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetWinrtDisplayNV", "physicalDevice, deviceRelativeId, pDisplay", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetWinrtDisplayNV(api_dump, physicalDevice, deviceRelativeId, pDisplay);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetWinrtDisplayNV<Format>(ApiDumpInstance::current(), physicalDevice, deviceRelativeId, pDisplay);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetWinrtDisplayNV(api_dump, physicalDevice, deviceRelativeId, pDisplay);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDirectFBSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDirectFBSurfaceEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateDirectFBSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDirectFBSurfaceEXT(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDirectFBSurfaceEXT<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDirectFBSurfaceEXT(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDirectFBPresentationSupportEXT", "physicalDevice, queueFamilyIndex, dfb", "VkBool32");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dfb);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT", "physicalDevice, queueFamilyIndex, dfb", "VkBool32");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(api_dump, physicalDevice, queueFamilyIndex, dfb);
         }
     }
     VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkBool32", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dfb);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkBool32", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(api_dump, physicalDevice, queueFamilyIndex, dfb);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateScreenSurfaceQNX", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateScreenSurfaceQNX<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateScreenSurfaceQNX", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateScreenSurfaceQNX(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateScreenSurfaceQNX<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateScreenSurfaceQNX(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceScreenPresentationSupportQNX", "physicalDevice, queueFamilyIndex, window", "VkBool32");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, window);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceScreenPresentationSupportQNX", "physicalDevice, queueFamilyIndex, window", "VkBool32");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(api_dump, physicalDevice, queueFamilyIndex, window);
         }
     }
     VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkBool32", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, window);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkBool32", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(api_dump, physicalDevice, queueFamilyIndex, window);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalTensorPropertiesARM", "physicalDevice, pExternalTensorInfo, pExternalTensorProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM<Format>(ApiDumpInstance::current(), physicalDevice, pExternalTensorInfo, pExternalTensorProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceExternalTensorPropertiesARM", "physicalDevice, pExternalTensorInfo, pExternalTensorProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(api_dump, physicalDevice, pExternalTensorInfo, pExternalTensorProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, pExternalTensorProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM<Format>(ApiDumpInstance::current(), physicalDevice, pExternalTensorInfo, pExternalTensorProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(api_dump, physicalDevice, pExternalTensorInfo, pExternalTensorProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceOpticalFlowImageFormatsNV", "physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV<Format>(ApiDumpInstance::current(), physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV", "physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(api_dump, physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV<Format>(ApiDumpInstance::current(), physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(api_dump, physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeVectorPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM", "physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM", "physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(api_dump, physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(api_dump, physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM", "physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM", "physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(api_dump, physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties);
         }
     }
     instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM<Format>(ApiDumpInstance::current(), physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(api_dump, physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_OHOS)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSurfaceOHOS", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSurfaceOHOS<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkCreateSurfaceOHOS", "instance, pCreateInfo, pAllocator, pSurface", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSurfaceOHOS(api_dump, instance, pCreateInfo, pAllocator, pSurface);
         }
     }
     VkResult result = instance_dispatch_table(instance)->CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSurfaceOHOS<Format>(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSurfaceOHOS(api_dump, instance, pCreateInfo, pAllocator, pSurface);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_OHOS
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(api_dump, physicalDevice, pPropertyCount, pProperties);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, pPropertyCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV<Format>(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(api_dump, physicalDevice, pPropertyCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", "physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", "physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(api_dump, physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
         }
     }
     VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM<Format>(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(api_dump, physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 
 // Autogen device functions
 
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDevice", "device, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDevice<Format>(ApiDumpInstance::current(), device, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDevice", "device, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDevice(api_dump, device, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDevice(device, pAllocator);
     destroy_device_dispatch_table(get_dispatch_key(device));
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDevice<Format>(ApiDumpInstance::current(), device, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDevice(api_dump, device, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceQueue", "device, queueFamilyIndex, queueIndex, pQueue", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceQueue<Format>(ApiDumpInstance::current(), device, queueFamilyIndex, queueIndex, pQueue);
+    dump_function_head(api_dump, "vkGetDeviceQueue", "device, queueFamilyIndex, queueIndex, pQueue", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceQueue(api_dump, device, queueFamilyIndex, queueIndex, pQueue);
         }
     }
     device_dispatch_table(device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceQueue<Format>(ApiDumpInstance::current(), device, queueFamilyIndex, queueIndex, pQueue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceQueue(api_dump, device, queueFamilyIndex, queueIndex, pQueue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueSubmit", "queue, submitCount, pSubmits, fence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueSubmit<Format>(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence);
+    dump_function_head(api_dump, "vkQueueSubmit", "queue, submitCount, pSubmits, fence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueSubmit(api_dump, queue, submitCount, pSubmits, fence);
         }
     }
     VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, submitCount, pSubmits, fence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueSubmit<Format>(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueSubmit(api_dump, queue, submitCount, pSubmits, fence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkQueueWaitIdle", "queue", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueWaitIdle<Format>(ApiDumpInstance::current(), queue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkQueueWaitIdle", "queue", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueWaitIdle(api_dump, queue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkDeviceWaitIdle", "device", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDeviceWaitIdle<Format>(ApiDumpInstance::current(), device);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkDeviceWaitIdle", "device", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDeviceWaitIdle(api_dump, device);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAllocateMemory", "device, pAllocateInfo, pAllocator, pMemory", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAllocateMemory<Format>(ApiDumpInstance::current(), device, pAllocateInfo, pAllocator, pMemory);
+    dump_function_head(api_dump, "vkAllocateMemory", "device, pAllocateInfo, pAllocator, pMemory", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAllocateMemory(api_dump, device, pAllocateInfo, pAllocator, pMemory);
         }
     }
     VkResult result = device_dispatch_table(device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAllocateMemory<Format>(ApiDumpInstance::current(), device, pAllocateInfo, pAllocator, pMemory);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAllocateMemory(api_dump, device, pAllocateInfo, pAllocator, pMemory);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkFreeMemory", "device, memory, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkFreeMemory<Format>(ApiDumpInstance::current(), device, memory, pAllocator);
+    dump_function_head(api_dump, "vkFreeMemory", "device, memory, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkFreeMemory(api_dump, device, memory, pAllocator);
         }
     }
     device_dispatch_table(device)->FreeMemory(device, memory, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkFreeMemory<Format>(ApiDumpInstance::current(), device, memory, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkFreeMemory(api_dump, device, memory, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkMapMemory", "device, memory, offset, size, flags, ppData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkMapMemory<Format>(ApiDumpInstance::current(), device, memory, offset, size, flags, ppData);
+    dump_function_head(api_dump, "vkMapMemory", "device, memory, offset, size, flags, ppData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkMapMemory(api_dump, device, memory, offset, size, flags, ppData);
         }
     }
     VkResult result = device_dispatch_table(device)->MapMemory(device, memory, offset, size, flags, ppData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkMapMemory<Format>(ApiDumpInstance::current(), device, memory, offset, size, flags, ppData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkMapMemory(api_dump, device, memory, offset, size, flags, ppData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUnmapMemory", "device, memory", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUnmapMemory<Format>(ApiDumpInstance::current(), device, memory);
+    dump_function_head(api_dump, "vkUnmapMemory", "device, memory", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUnmapMemory(api_dump, device, memory);
         }
     }
     device_dispatch_table(device)->UnmapMemory(device, memory);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUnmapMemory<Format>(ApiDumpInstance::current(), device, memory);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUnmapMemory(api_dump, device, memory);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkFlushMappedMemoryRanges", "device, memoryRangeCount, pMemoryRanges", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkFlushMappedMemoryRanges<Format>(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges);
+    dump_function_head(api_dump, "vkFlushMappedMemoryRanges", "device, memoryRangeCount, pMemoryRanges", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkFlushMappedMemoryRanges(api_dump, device, memoryRangeCount, pMemoryRanges);
         }
     }
     VkResult result = device_dispatch_table(device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkFlushMappedMemoryRanges<Format>(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkFlushMappedMemoryRanges(api_dump, device, memoryRangeCount, pMemoryRanges);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkInvalidateMappedMemoryRanges", "device, memoryRangeCount, pMemoryRanges", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkInvalidateMappedMemoryRanges<Format>(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges);
+    dump_function_head(api_dump, "vkInvalidateMappedMemoryRanges", "device, memoryRangeCount, pMemoryRanges", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkInvalidateMappedMemoryRanges(api_dump, device, memoryRangeCount, pMemoryRanges);
         }
     }
     VkResult result = device_dispatch_table(device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkInvalidateMappedMemoryRanges<Format>(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkInvalidateMappedMemoryRanges(api_dump, device, memoryRangeCount, pMemoryRanges);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMemoryCommitment", "device, memory, pCommittedMemoryInBytes", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceMemoryCommitment<Format>(ApiDumpInstance::current(), device, memory, pCommittedMemoryInBytes);
+    dump_function_head(api_dump, "vkGetDeviceMemoryCommitment", "device, memory, pCommittedMemoryInBytes", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceMemoryCommitment(api_dump, device, memory, pCommittedMemoryInBytes);
         }
     }
     device_dispatch_table(device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceMemoryCommitment<Format>(ApiDumpInstance::current(), device, memory, pCommittedMemoryInBytes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceMemoryCommitment(api_dump, device, memory, pCommittedMemoryInBytes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindBufferMemory", "device, buffer, memory, memoryOffset", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindBufferMemory<Format>(ApiDumpInstance::current(), device, buffer, memory, memoryOffset);
+    dump_function_head(api_dump, "vkBindBufferMemory", "device, buffer, memory, memoryOffset", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindBufferMemory(api_dump, device, buffer, memory, memoryOffset);
         }
     }
     VkResult result = device_dispatch_table(device)->BindBufferMemory(device, buffer, memory, memoryOffset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindBufferMemory<Format>(ApiDumpInstance::current(), device, buffer, memory, memoryOffset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindBufferMemory(api_dump, device, buffer, memory, memoryOffset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindImageMemory", "device, image, memory, memoryOffset", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindImageMemory<Format>(ApiDumpInstance::current(), device, image, memory, memoryOffset);
+    dump_function_head(api_dump, "vkBindImageMemory", "device, image, memory, memoryOffset", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindImageMemory(api_dump, device, image, memory, memoryOffset);
         }
     }
     VkResult result = device_dispatch_table(device)->BindImageMemory(device, image, memory, memoryOffset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindImageMemory<Format>(ApiDumpInstance::current(), device, image, memory, memoryOffset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindImageMemory(api_dump, device, image, memory, memoryOffset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferMemoryRequirements", "device, buffer, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferMemoryRequirements<Format>(ApiDumpInstance::current(), device, buffer, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetBufferMemoryRequirements", "device, buffer, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferMemoryRequirements(api_dump, device, buffer, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferMemoryRequirements<Format>(ApiDumpInstance::current(), device, buffer, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferMemoryRequirements(api_dump, device, buffer, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageMemoryRequirements", "device, image, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageMemoryRequirements<Format>(ApiDumpInstance::current(), device, image, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetImageMemoryRequirements", "device, image, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageMemoryRequirements(api_dump, device, image, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageMemoryRequirements<Format>(ApiDumpInstance::current(), device, image, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageMemoryRequirements(api_dump, device, image, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSparseMemoryRequirements", "device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSparseMemoryRequirements<Format>(ApiDumpInstance::current(), device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    dump_function_head(api_dump, "vkGetImageSparseMemoryRequirements", "device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSparseMemoryRequirements(api_dump, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSparseMemoryRequirements<Format>(ApiDumpInstance::current(), device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSparseMemoryRequirements(api_dump, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueBindSparse", "queue, bindInfoCount, pBindInfo, fence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueBindSparse<Format>(ApiDumpInstance::current(), queue, bindInfoCount, pBindInfo, fence);
+    dump_function_head(api_dump, "vkQueueBindSparse", "queue, bindInfoCount, pBindInfo, fence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueBindSparse(api_dump, queue, bindInfoCount, pBindInfo, fence);
         }
     }
     VkResult result = device_dispatch_table(queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueBindSparse<Format>(ApiDumpInstance::current(), queue, bindInfoCount, pBindInfo, fence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueBindSparse(api_dump, queue, bindInfoCount, pBindInfo, fence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateFence", "device, pCreateInfo, pAllocator, pFence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateFence<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFence);
+    dump_function_head(api_dump, "vkCreateFence", "device, pCreateInfo, pAllocator, pFence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateFence(api_dump, device, pCreateInfo, pAllocator, pFence);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateFence<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateFence(api_dump, device, pCreateInfo, pAllocator, pFence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyFence", "device, fence, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyFence<Format>(ApiDumpInstance::current(), device, fence, pAllocator);
+    dump_function_head(api_dump, "vkDestroyFence", "device, fence, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyFence(api_dump, device, fence, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyFence(device, fence, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyFence<Format>(ApiDumpInstance::current(), device, fence, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyFence(api_dump, device, fence, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetFences", "device, fenceCount, pFences", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetFences<Format>(ApiDumpInstance::current(), device, fenceCount, pFences);
+    dump_function_head(api_dump, "vkResetFences", "device, fenceCount, pFences", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetFences(api_dump, device, fenceCount, pFences);
         }
     }
     VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetFences<Format>(ApiDumpInstance::current(), device, fenceCount, pFences);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetFences(api_dump, device, fenceCount, pFences);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetFenceStatus", "device, fence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetFenceStatus<Format>(ApiDumpInstance::current(), device, fence);
+    dump_function_head(api_dump, "vkGetFenceStatus", "device, fence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetFenceStatus(api_dump, device, fence);
         }
     }
     VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetFenceStatus<Format>(ApiDumpInstance::current(), device, fence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetFenceStatus(api_dump, device, fence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkWaitForFences", "device, fenceCount, pFences, waitAll, timeout", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWaitForFences<Format>(ApiDumpInstance::current(), device, fenceCount, pFences, waitAll, timeout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkWaitForFences", "device, fenceCount, pFences, waitAll, timeout", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWaitForFences(api_dump, device, fenceCount, pFences, waitAll, timeout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSemaphore", "device, pCreateInfo, pAllocator, pSemaphore", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSemaphore<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSemaphore);
+    dump_function_head(api_dump, "vkCreateSemaphore", "device, pCreateInfo, pAllocator, pSemaphore", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSemaphore(api_dump, device, pCreateInfo, pAllocator, pSemaphore);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSemaphore<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSemaphore);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSemaphore(api_dump, device, pCreateInfo, pAllocator, pSemaphore);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroySemaphore", "device, semaphore, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroySemaphore<Format>(ApiDumpInstance::current(), device, semaphore, pAllocator);
+    dump_function_head(api_dump, "vkDestroySemaphore", "device, semaphore, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroySemaphore(api_dump, device, semaphore, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroySemaphore(device, semaphore, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroySemaphore<Format>(ApiDumpInstance::current(), device, semaphore, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroySemaphore(api_dump, device, semaphore, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateQueryPool", "device, pCreateInfo, pAllocator, pQueryPool", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateQueryPool<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pQueryPool);
+    dump_function_head(api_dump, "vkCreateQueryPool", "device, pCreateInfo, pAllocator, pQueryPool", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateQueryPool(api_dump, device, pCreateInfo, pAllocator, pQueryPool);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateQueryPool<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pQueryPool);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateQueryPool(api_dump, device, pCreateInfo, pAllocator, pQueryPool);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyQueryPool", "device, queryPool, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyQueryPool<Format>(ApiDumpInstance::current(), device, queryPool, pAllocator);
+    dump_function_head(api_dump, "vkDestroyQueryPool", "device, queryPool, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyQueryPool(api_dump, device, queryPool, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyQueryPool(device, queryPool, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyQueryPool<Format>(ApiDumpInstance::current(), device, queryPool, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyQueryPool(api_dump, device, queryPool, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkGetQueryPoolResults", "device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetQueryPoolResults<Format>(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkGetQueryPoolResults", "device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetQueryPoolResults(api_dump, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateBuffer", "device, pCreateInfo, pAllocator, pBuffer", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateBuffer<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBuffer);
+    dump_function_head(api_dump, "vkCreateBuffer", "device, pCreateInfo, pAllocator, pBuffer", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateBuffer(api_dump, device, pCreateInfo, pAllocator, pBuffer);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateBuffer<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateBuffer(api_dump, device, pCreateInfo, pAllocator, pBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyBuffer", "device, buffer, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyBuffer<Format>(ApiDumpInstance::current(), device, buffer, pAllocator);
+    dump_function_head(api_dump, "vkDestroyBuffer", "device, buffer, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyBuffer(api_dump, device, buffer, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyBuffer(device, buffer, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyBuffer<Format>(ApiDumpInstance::current(), device, buffer, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyBuffer(api_dump, device, buffer, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateImage", "device, pCreateInfo, pAllocator, pImage", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateImage<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pImage);
+    dump_function_head(api_dump, "vkCreateImage", "device, pCreateInfo, pAllocator, pImage", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateImage(api_dump, device, pCreateInfo, pAllocator, pImage);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pAllocator, pImage);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateImage<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pImage);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateImage(api_dump, device, pCreateInfo, pAllocator, pImage);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyImage", "device, image, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyImage<Format>(ApiDumpInstance::current(), device, image, pAllocator);
+    dump_function_head(api_dump, "vkDestroyImage", "device, image, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyImage(api_dump, device, image, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyImage(device, image, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyImage<Format>(ApiDumpInstance::current(), device, image, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyImage(api_dump, device, image, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout", "device, image, pSubresource, pLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSubresourceLayout<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
+    dump_function_head(api_dump, "vkGetImageSubresourceLayout", "device, image, pSubresource, pLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSubresourceLayout(api_dump, device, image, pSubresource, pLayout);
         }
     }
     device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSubresourceLayout<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSubresourceLayout(api_dump, device, image, pSubresource, pLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateImageView", "device, pCreateInfo, pAllocator, pView", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateImageView<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView);
+    dump_function_head(api_dump, "vkCreateImageView", "device, pCreateInfo, pAllocator, pView", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateImageView(api_dump, device, pCreateInfo, pAllocator, pView);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pAllocator, pView);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateImageView<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateImageView(api_dump, device, pCreateInfo, pAllocator, pView);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyImageView", "device, imageView, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyImageView<Format>(ApiDumpInstance::current(), device, imageView, pAllocator);
+    dump_function_head(api_dump, "vkDestroyImageView", "device, imageView, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyImageView(api_dump, device, imageView, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyImageView(device, imageView, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyImageView<Format>(ApiDumpInstance::current(), device, imageView, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyImageView(api_dump, device, imageView, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateCommandPool", "device, pCreateInfo, pAllocator, pCommandPool", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateCommandPool<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCommandPool);
+    dump_function_head(api_dump, "vkCreateCommandPool", "device, pCreateInfo, pAllocator, pCommandPool", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateCommandPool(api_dump, device, pCreateInfo, pAllocator, pCommandPool);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateCommandPool<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCommandPool);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateCommandPool(api_dump, device, pCreateInfo, pAllocator, pCommandPool);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyCommandPool", "device, commandPool, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyCommandPool<Format>(ApiDumpInstance::current(), device, commandPool, pAllocator);
+    dump_function_head(api_dump, "vkDestroyCommandPool", "device, commandPool, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyCommandPool(api_dump, device, commandPool, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyCommandPool(device, commandPool, pAllocator);
-    ApiDumpInstance::current().eraseCmdBufferPool(device, commandPool);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyCommandPool<Format>(ApiDumpInstance::current(), device, commandPool, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    api_dump.eraseCmdBufferPool(device, commandPool);
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyCommandPool(api_dump, device, commandPool, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetCommandPool", "device, commandPool, flags", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetCommandPool<Format>(ApiDumpInstance::current(), device, commandPool, flags);
+    dump_function_head(api_dump, "vkResetCommandPool", "device, commandPool, flags", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetCommandPool(api_dump, device, commandPool, flags);
         }
     }
     VkResult result = device_dispatch_table(device)->ResetCommandPool(device, commandPool, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetCommandPool<Format>(ApiDumpInstance::current(), device, commandPool, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetCommandPool(api_dump, device, commandPool, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAllocateCommandBuffers", "device, pAllocateInfo, pCommandBuffers", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAllocateCommandBuffers<Format>(ApiDumpInstance::current(), device, pAllocateInfo, pCommandBuffers);
+    dump_function_head(api_dump, "vkAllocateCommandBuffers", "device, pAllocateInfo, pCommandBuffers", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAllocateCommandBuffers(api_dump, device, pAllocateInfo, pCommandBuffers);
         }
     }
     VkResult result = device_dispatch_table(device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
     if (result == VK_SUCCESS)
-        ApiDumpInstance::current().addCmdBuffers(
+        api_dump.addCmdBuffers(
             device,
             pAllocateInfo->commandPool,
             std::vector<VkCommandBuffer>(pCommandBuffers, pCommandBuffers + pAllocateInfo->commandBufferCount),
             pAllocateInfo->level);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAllocateCommandBuffers<Format>(ApiDumpInstance::current(), device, pAllocateInfo, pCommandBuffers);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAllocateCommandBuffers(api_dump, device, pAllocateInfo, pCommandBuffers);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkFreeCommandBuffers", "device, commandPool, commandBufferCount, pCommandBuffers", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkFreeCommandBuffers<Format>(ApiDumpInstance::current(), device, commandPool, commandBufferCount, pCommandBuffers);
+    dump_function_head(api_dump, "vkFreeCommandBuffers", "device, commandPool, commandBufferCount, pCommandBuffers", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkFreeCommandBuffers(api_dump, device, commandPool, commandBufferCount, pCommandBuffers);
         }
     }
     device_dispatch_table(device)->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-    ApiDumpInstance::current().eraseCmdBuffers(device, commandPool, std::vector<VkCommandBuffer>(pCommandBuffers, pCommandBuffers + commandBufferCount));
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkFreeCommandBuffers<Format>(ApiDumpInstance::current(), device, commandPool, commandBufferCount, pCommandBuffers);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    api_dump.eraseCmdBuffers(device, commandPool, std::vector<VkCommandBuffer>(pCommandBuffers, pCommandBuffers + commandBufferCount));
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkFreeCommandBuffers(api_dump, device, commandPool, commandBufferCount, pCommandBuffers);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBeginCommandBuffer", "commandBuffer, pBeginInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBeginCommandBuffer<Format>(ApiDumpInstance::current(), commandBuffer, pBeginInfo);
+    dump_function_head(api_dump, "vkBeginCommandBuffer", "commandBuffer, pBeginInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBeginCommandBuffer(api_dump, commandBuffer, pBeginInfo);
         }
     }
     VkResult result = device_dispatch_table(commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBeginCommandBuffer<Format>(ApiDumpInstance::current(), commandBuffer, pBeginInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBeginCommandBuffer(api_dump, commandBuffer, pBeginInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkEndCommandBuffer", "commandBuffer", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkEndCommandBuffer<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkEndCommandBuffer", "commandBuffer", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkEndCommandBuffer(api_dump, commandBuffer);
         }
     }
     VkResult result = device_dispatch_table(commandBuffer)->EndCommandBuffer(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkEndCommandBuffer<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkEndCommandBuffer(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetCommandBuffer", "commandBuffer, flags", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetCommandBuffer<Format>(ApiDumpInstance::current(), commandBuffer, flags);
+    dump_function_head(api_dump, "vkResetCommandBuffer", "commandBuffer, flags", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetCommandBuffer(api_dump, commandBuffer, flags);
         }
     }
     VkResult result = device_dispatch_table(commandBuffer)->ResetCommandBuffer(commandBuffer, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetCommandBuffer<Format>(ApiDumpInstance::current(), commandBuffer, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetCommandBuffer(api_dump, commandBuffer, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBuffer", "commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyBuffer<Format>(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+    dump_function_head(api_dump, "vkCmdCopyBuffer", "commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyBuffer(api_dump, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyBuffer<Format>(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyBuffer(api_dump, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyImage<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    dump_function_head(api_dump, "vkCmdCopyImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyImage(api_dump, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyImage<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyImage(api_dump, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBufferToImage", "commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyBufferToImage<Format>(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+    dump_function_head(api_dump, "vkCmdCopyBufferToImage", "commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyBufferToImage(api_dump, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyBufferToImage<Format>(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyBufferToImage(api_dump, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImageToBuffer", "commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyImageToBuffer<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+    dump_function_head(api_dump, "vkCmdCopyImageToBuffer", "commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyImageToBuffer(api_dump, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyImageToBuffer<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyImageToBuffer(api_dump, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdUpdateBuffer", "commandBuffer, dstBuffer, dstOffset, dataSize, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdUpdateBuffer<Format>(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+    dump_function_head(api_dump, "vkCmdUpdateBuffer", "commandBuffer, dstBuffer, dstOffset, dataSize, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdUpdateBuffer(api_dump, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
         }
     }
     device_dispatch_table(commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdUpdateBuffer<Format>(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdUpdateBuffer(api_dump, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdFillBuffer", "commandBuffer, dstBuffer, dstOffset, size, data", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdFillBuffer<Format>(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, size, data);
+    dump_function_head(api_dump, "vkCmdFillBuffer", "commandBuffer, dstBuffer, dstOffset, size, data", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdFillBuffer(api_dump, commandBuffer, dstBuffer, dstOffset, size, data);
         }
     }
     device_dispatch_table(commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdFillBuffer<Format>(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, size, data);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdFillBuffer(api_dump, commandBuffer, dstBuffer, dstOffset, size, data);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(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) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPipelineBarrier", "commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPipelineBarrier<Format>(ApiDumpInstance::current(), commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    dump_function_head(api_dump, "vkCmdPipelineBarrier", "commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPipelineBarrier(api_dump, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPipelineBarrier<Format>(ApiDumpInstance::current(), commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPipelineBarrier(api_dump, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginQuery", "commandBuffer, queryPool, query, flags", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginQuery<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags);
+    dump_function_head(api_dump, "vkCmdBeginQuery", "commandBuffer, queryPool, query, flags", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginQuery(api_dump, commandBuffer, queryPool, query, flags);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginQuery<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginQuery(api_dump, commandBuffer, queryPool, query, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndQuery", "commandBuffer, queryPool, query", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndQuery<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query);
+    dump_function_head(api_dump, "vkCmdEndQuery", "commandBuffer, queryPool, query", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndQuery(api_dump, commandBuffer, queryPool, query);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndQuery<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndQuery(api_dump, commandBuffer, queryPool, query);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResetQueryPool", "commandBuffer, queryPool, firstQuery, queryCount", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResetQueryPool<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount);
+    dump_function_head(api_dump, "vkCmdResetQueryPool", "commandBuffer, queryPool, firstQuery, queryCount", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResetQueryPool(api_dump, commandBuffer, queryPool, firstQuery, queryCount);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResetQueryPool<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResetQueryPool(api_dump, commandBuffer, queryPool, firstQuery, queryCount);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteTimestamp", "commandBuffer, pipelineStage, queryPool, query", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteTimestamp<Format>(ApiDumpInstance::current(), commandBuffer, pipelineStage, queryPool, query);
+    dump_function_head(api_dump, "vkCmdWriteTimestamp", "commandBuffer, pipelineStage, queryPool, query", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteTimestamp(api_dump, commandBuffer, pipelineStage, queryPool, query);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteTimestamp<Format>(ApiDumpInstance::current(), commandBuffer, pipelineStage, queryPool, query);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteTimestamp(api_dump, commandBuffer, pipelineStage, queryPool, query);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyQueryPoolResults", "commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyQueryPoolResults<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+    dump_function_head(api_dump, "vkCmdCopyQueryPoolResults", "commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyQueryPoolResults(api_dump, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyQueryPoolResults<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyQueryPoolResults(api_dump, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdExecuteCommands", "commandBuffer, commandBufferCount, pCommandBuffers", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdExecuteCommands<Format>(ApiDumpInstance::current(), commandBuffer, commandBufferCount, pCommandBuffers);
+    dump_function_head(api_dump, "vkCmdExecuteCommands", "commandBuffer, commandBufferCount, pCommandBuffers", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdExecuteCommands(api_dump, commandBuffer, commandBufferCount, pCommandBuffers);
         }
     }
     device_dispatch_table(commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdExecuteCommands<Format>(ApiDumpInstance::current(), commandBuffer, commandBufferCount, pCommandBuffers);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdExecuteCommands(api_dump, commandBuffer, commandBufferCount, pCommandBuffers);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateEvent", "device, pCreateInfo, pAllocator, pEvent", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateEvent<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pEvent);
+    dump_function_head(api_dump, "vkCreateEvent", "device, pCreateInfo, pAllocator, pEvent", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateEvent(api_dump, device, pCreateInfo, pAllocator, pEvent);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateEvent<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pEvent);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateEvent(api_dump, device, pCreateInfo, pAllocator, pEvent);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyEvent", "device, event, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyEvent<Format>(ApiDumpInstance::current(), device, event, pAllocator);
+    dump_function_head(api_dump, "vkDestroyEvent", "device, event, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyEvent(api_dump, device, event, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyEvent(device, event, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyEvent<Format>(ApiDumpInstance::current(), device, event, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyEvent(api_dump, device, event, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetEventStatus", "device, event", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetEventStatus<Format>(ApiDumpInstance::current(), device, event);
+    dump_function_head(api_dump, "vkGetEventStatus", "device, event", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetEventStatus(api_dump, device, event);
         }
     }
     VkResult result = device_dispatch_table(device)->GetEventStatus(device, event);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetEventStatus<Format>(ApiDumpInstance::current(), device, event);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetEventStatus(api_dump, device, event);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetEvent", "device, event", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetEvent<Format>(ApiDumpInstance::current(), device, event);
+    dump_function_head(api_dump, "vkSetEvent", "device, event", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetEvent(api_dump, device, event);
         }
     }
     VkResult result = device_dispatch_table(device)->SetEvent(device, event);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetEvent<Format>(ApiDumpInstance::current(), device, event);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetEvent(api_dump, device, event);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetEvent", "device, event", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetEvent<Format>(ApiDumpInstance::current(), device, event);
+    dump_function_head(api_dump, "vkResetEvent", "device, event", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetEvent(api_dump, device, event);
         }
     }
     VkResult result = device_dispatch_table(device)->ResetEvent(device, event);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetEvent<Format>(ApiDumpInstance::current(), device, event);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetEvent(api_dump, device, event);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateBufferView", "device, pCreateInfo, pAllocator, pView", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateBufferView<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView);
+    dump_function_head(api_dump, "vkCreateBufferView", "device, pCreateInfo, pAllocator, pView", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateBufferView(api_dump, device, pCreateInfo, pAllocator, pView);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pAllocator, pView);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateBufferView<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateBufferView(api_dump, device, pCreateInfo, pAllocator, pView);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyBufferView", "device, bufferView, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyBufferView<Format>(ApiDumpInstance::current(), device, bufferView, pAllocator);
+    dump_function_head(api_dump, "vkDestroyBufferView", "device, bufferView, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyBufferView(api_dump, device, bufferView, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyBufferView(device, bufferView, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyBufferView<Format>(ApiDumpInstance::current(), device, bufferView, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyBufferView(api_dump, device, bufferView, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateShaderModule", "device, pCreateInfo, pAllocator, pShaderModule", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateShaderModule<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pShaderModule);
+    dump_function_head(api_dump, "vkCreateShaderModule", "device, pCreateInfo, pAllocator, pShaderModule", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateShaderModule(api_dump, device, pCreateInfo, pAllocator, pShaderModule);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateShaderModule<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pShaderModule);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateShaderModule(api_dump, device, pCreateInfo, pAllocator, pShaderModule);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyShaderModule", "device, shaderModule, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyShaderModule<Format>(ApiDumpInstance::current(), device, shaderModule, pAllocator);
+    dump_function_head(api_dump, "vkDestroyShaderModule", "device, shaderModule, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyShaderModule(api_dump, device, shaderModule, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyShaderModule(device, shaderModule, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyShaderModule<Format>(ApiDumpInstance::current(), device, shaderModule, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyShaderModule(api_dump, device, shaderModule, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreatePipelineCache", "device, pCreateInfo, pAllocator, pPipelineCache", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreatePipelineCache<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineCache);
+    dump_function_head(api_dump, "vkCreatePipelineCache", "device, pCreateInfo, pAllocator, pPipelineCache", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreatePipelineCache(api_dump, device, pCreateInfo, pAllocator, pPipelineCache);
         }
     }
     VkResult result = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreatePipelineCache<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineCache);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreatePipelineCache(api_dump, device, pCreateInfo, pAllocator, pPipelineCache);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyPipelineCache", "device, pipelineCache, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyPipelineCache<Format>(ApiDumpInstance::current(), device, pipelineCache, pAllocator);
+    dump_function_head(api_dump, "vkDestroyPipelineCache", "device, pipelineCache, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyPipelineCache(api_dump, device, pipelineCache, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyPipelineCache(device, pipelineCache, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyPipelineCache<Format>(ApiDumpInstance::current(), device, pipelineCache, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyPipelineCache(api_dump, device, pipelineCache, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineCacheData", "device, pipelineCache, pDataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineCacheData<Format>(ApiDumpInstance::current(), device, pipelineCache, pDataSize, pData);
+    dump_function_head(api_dump, "vkGetPipelineCacheData", "device, pipelineCache, pDataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineCacheData(api_dump, device, pipelineCache, pDataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineCacheData<Format>(ApiDumpInstance::current(), device, pipelineCache, pDataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineCacheData(api_dump, device, pipelineCache, pDataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkMergePipelineCaches", "device, dstCache, srcCacheCount, pSrcCaches", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkMergePipelineCaches<Format>(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches);
+    dump_function_head(api_dump, "vkMergePipelineCaches", "device, dstCache, srcCacheCount, pSrcCaches", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkMergePipelineCaches(api_dump, device, dstCache, srcCacheCount, pSrcCaches);
         }
     }
     VkResult result = device_dispatch_table(device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkMergePipelineCaches<Format>(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkMergePipelineCaches(api_dump, device, dstCache, srcCacheCount, pSrcCaches);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateComputePipelines", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateComputePipelines<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    dump_function_head(api_dump, "vkCreateComputePipelines", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateComputePipelines(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateComputePipelines<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateComputePipelines(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyPipeline", "device, pipeline, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyPipeline<Format>(ApiDumpInstance::current(), device, pipeline, pAllocator);
+    dump_function_head(api_dump, "vkDestroyPipeline", "device, pipeline, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyPipeline(api_dump, device, pipeline, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyPipeline(device, pipeline, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyPipeline<Format>(ApiDumpInstance::current(), device, pipeline, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyPipeline(api_dump, device, pipeline, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreatePipelineLayout", "device, pCreateInfo, pAllocator, pPipelineLayout", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreatePipelineLayout<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineLayout);
+    dump_function_head(api_dump, "vkCreatePipelineLayout", "device, pCreateInfo, pAllocator, pPipelineLayout", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreatePipelineLayout(api_dump, device, pCreateInfo, pAllocator, pPipelineLayout);
         }
     }
     VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreatePipelineLayout<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreatePipelineLayout(api_dump, device, pCreateInfo, pAllocator, pPipelineLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyPipelineLayout", "device, pipelineLayout, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyPipelineLayout<Format>(ApiDumpInstance::current(), device, pipelineLayout, pAllocator);
+    dump_function_head(api_dump, "vkDestroyPipelineLayout", "device, pipelineLayout, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyPipelineLayout(api_dump, device, pipelineLayout, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyPipelineLayout<Format>(ApiDumpInstance::current(), device, pipelineLayout, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyPipelineLayout(api_dump, device, pipelineLayout, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSampler", "device, pCreateInfo, pAllocator, pSampler", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSampler<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSampler);
+    dump_function_head(api_dump, "vkCreateSampler", "device, pCreateInfo, pAllocator, pSampler", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSampler(api_dump, device, pCreateInfo, pAllocator, pSampler);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSampler<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSampler);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSampler(api_dump, device, pCreateInfo, pAllocator, pSampler);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroySampler", "device, sampler, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroySampler<Format>(ApiDumpInstance::current(), device, sampler, pAllocator);
+    dump_function_head(api_dump, "vkDestroySampler", "device, sampler, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroySampler(api_dump, device, sampler, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroySampler(device, sampler, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroySampler<Format>(ApiDumpInstance::current(), device, sampler, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroySampler(api_dump, device, sampler, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorSetLayout", "device, pCreateInfo, pAllocator, pSetLayout", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDescriptorSetLayout<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSetLayout);
+    dump_function_head(api_dump, "vkCreateDescriptorSetLayout", "device, pCreateInfo, pAllocator, pSetLayout", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDescriptorSetLayout(api_dump, device, pCreateInfo, pAllocator, pSetLayout);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDescriptorSetLayout<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSetLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDescriptorSetLayout(api_dump, device, pCreateInfo, pAllocator, pSetLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorSetLayout", "device, descriptorSetLayout, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDescriptorSetLayout<Format>(ApiDumpInstance::current(), device, descriptorSetLayout, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDescriptorSetLayout", "device, descriptorSetLayout, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDescriptorSetLayout(api_dump, device, descriptorSetLayout, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDescriptorSetLayout<Format>(ApiDumpInstance::current(), device, descriptorSetLayout, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDescriptorSetLayout(api_dump, device, descriptorSetLayout, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorPool", "device, pCreateInfo, pAllocator, pDescriptorPool", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDescriptorPool<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorPool);
+    dump_function_head(api_dump, "vkCreateDescriptorPool", "device, pCreateInfo, pAllocator, pDescriptorPool", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDescriptorPool(api_dump, device, pCreateInfo, pAllocator, pDescriptorPool);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDescriptorPool<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorPool);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDescriptorPool(api_dump, device, pCreateInfo, pAllocator, pDescriptorPool);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorPool", "device, descriptorPool, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDescriptorPool<Format>(ApiDumpInstance::current(), device, descriptorPool, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDescriptorPool", "device, descriptorPool, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDescriptorPool(api_dump, device, descriptorPool, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDescriptorPool(device, descriptorPool, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDescriptorPool<Format>(ApiDumpInstance::current(), device, descriptorPool, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDescriptorPool(api_dump, device, descriptorPool, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetDescriptorPool", "device, descriptorPool, flags", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetDescriptorPool<Format>(ApiDumpInstance::current(), device, descriptorPool, flags);
+    dump_function_head(api_dump, "vkResetDescriptorPool", "device, descriptorPool, flags", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetDescriptorPool(api_dump, device, descriptorPool, flags);
         }
     }
     VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetDescriptorPool<Format>(ApiDumpInstance::current(), device, descriptorPool, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetDescriptorPool(api_dump, device, descriptorPool, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAllocateDescriptorSets", "device, pAllocateInfo, pDescriptorSets", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAllocateDescriptorSets<Format>(ApiDumpInstance::current(), device, pAllocateInfo, pDescriptorSets);
+    dump_function_head(api_dump, "vkAllocateDescriptorSets", "device, pAllocateInfo, pDescriptorSets", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAllocateDescriptorSets(api_dump, device, pAllocateInfo, pDescriptorSets);
         }
     }
     VkResult result = device_dispatch_table(device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAllocateDescriptorSets<Format>(ApiDumpInstance::current(), device, pAllocateInfo, pDescriptorSets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAllocateDescriptorSets(api_dump, device, pAllocateInfo, pDescriptorSets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkFreeDescriptorSets", "device, descriptorPool, descriptorSetCount, pDescriptorSets", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkFreeDescriptorSets<Format>(ApiDumpInstance::current(), device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    dump_function_head(api_dump, "vkFreeDescriptorSets", "device, descriptorPool, descriptorSetCount, pDescriptorSets", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkFreeDescriptorSets(api_dump, device, descriptorPool, descriptorSetCount, pDescriptorSets);
         }
     }
     VkResult result = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkFreeDescriptorSets<Format>(ApiDumpInstance::current(), device, descriptorPool, descriptorSetCount, pDescriptorSets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkFreeDescriptorSets(api_dump, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUpdateDescriptorSets", "device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUpdateDescriptorSets<Format>(ApiDumpInstance::current(), device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    dump_function_head(api_dump, "vkUpdateDescriptorSets", "device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUpdateDescriptorSets(api_dump, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
         }
     }
     device_dispatch_table(device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUpdateDescriptorSets<Format>(ApiDumpInstance::current(), device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUpdateDescriptorSets(api_dump, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindPipeline", "commandBuffer, pipelineBindPoint, pipeline", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindPipeline<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline);
+    dump_function_head(api_dump, "vkCmdBindPipeline", "commandBuffer, pipelineBindPoint, pipeline", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindPipeline(api_dump, commandBuffer, pipelineBindPoint, pipeline);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindPipeline<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindPipeline(api_dump, commandBuffer, pipelineBindPoint, pipeline);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorSets", "commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindDescriptorSets<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    dump_function_head(api_dump, "vkCmdBindDescriptorSets", "commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindDescriptorSets(api_dump, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindDescriptorSets<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindDescriptorSets(api_dump, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdClearColorImage", "commandBuffer, image, imageLayout, pColor, rangeCount, pRanges", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdClearColorImage<Format>(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    dump_function_head(api_dump, "vkCmdClearColorImage", "commandBuffer, image, imageLayout, pColor, rangeCount, pRanges", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdClearColorImage(api_dump, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
         }
     }
     device_dispatch_table(commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdClearColorImage<Format>(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdClearColorImage(api_dump, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatch", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatch<Format>(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ);
+    dump_function_head(api_dump, "vkCmdDispatch", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatch(api_dump, commandBuffer, groupCountX, groupCountY, groupCountZ);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatch<Format>(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatch(api_dump, commandBuffer, groupCountX, groupCountY, groupCountZ);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchIndirect", "commandBuffer, buffer, offset", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchIndirect<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset);
+    dump_function_head(api_dump, "vkCmdDispatchIndirect", "commandBuffer, buffer, offset", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchIndirect(api_dump, commandBuffer, buffer, offset);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchIndirect<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchIndirect(api_dump, commandBuffer, buffer, offset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetEvent", "commandBuffer, event, stageMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetEvent<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
+    dump_function_head(api_dump, "vkCmdSetEvent", "commandBuffer, event, stageMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetEvent(api_dump, commandBuffer, event, stageMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetEvent<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetEvent(api_dump, commandBuffer, event, stageMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResetEvent", "commandBuffer, event, stageMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResetEvent<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
+    dump_function_head(api_dump, "vkCmdResetEvent", "commandBuffer, event, stageMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResetEvent(api_dump, commandBuffer, event, stageMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResetEvent<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResetEvent(api_dump, commandBuffer, event, stageMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(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) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWaitEvents", "commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWaitEvents<Format>(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+    dump_function_head(api_dump, "vkCmdWaitEvents", "commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWaitEvents(api_dump, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWaitEvents<Format>(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWaitEvents(api_dump, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushConstants", "commandBuffer, layout, stageFlags, offset, size, pValues", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushConstants<Format>(ApiDumpInstance::current(), commandBuffer, layout, stageFlags, offset, size, pValues);
+    dump_function_head(api_dump, "vkCmdPushConstants", "commandBuffer, layout, stageFlags, offset, size, pValues", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushConstants(api_dump, commandBuffer, layout, stageFlags, offset, size, pValues);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushConstants<Format>(ApiDumpInstance::current(), commandBuffer, layout, stageFlags, offset, size, pValues);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushConstants(api_dump, commandBuffer, layout, stageFlags, offset, size, pValues);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateGraphicsPipelines", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateGraphicsPipelines<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    dump_function_head(api_dump, "vkCreateGraphicsPipelines", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateGraphicsPipelines(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateGraphicsPipelines<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateGraphicsPipelines(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateFramebuffer", "device, pCreateInfo, pAllocator, pFramebuffer", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateFramebuffer<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFramebuffer);
+    dump_function_head(api_dump, "vkCreateFramebuffer", "device, pCreateInfo, pAllocator, pFramebuffer", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateFramebuffer(api_dump, device, pCreateInfo, pAllocator, pFramebuffer);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateFramebuffer<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFramebuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateFramebuffer(api_dump, device, pCreateInfo, pAllocator, pFramebuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyFramebuffer", "device, framebuffer, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyFramebuffer<Format>(ApiDumpInstance::current(), device, framebuffer, pAllocator);
+    dump_function_head(api_dump, "vkDestroyFramebuffer", "device, framebuffer, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyFramebuffer(api_dump, device, framebuffer, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyFramebuffer(device, framebuffer, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyFramebuffer<Format>(ApiDumpInstance::current(), device, framebuffer, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyFramebuffer(api_dump, device, framebuffer, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateRenderPass", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateRenderPass<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass);
+    dump_function_head(api_dump, "vkCreateRenderPass", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateRenderPass(api_dump, device, pCreateInfo, pAllocator, pRenderPass);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateRenderPass<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateRenderPass(api_dump, device, pCreateInfo, pAllocator, pRenderPass);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyRenderPass", "device, renderPass, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyRenderPass<Format>(ApiDumpInstance::current(), device, renderPass, pAllocator);
+    dump_function_head(api_dump, "vkDestroyRenderPass", "device, renderPass, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyRenderPass(api_dump, device, renderPass, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyRenderPass(device, renderPass, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyRenderPass<Format>(ApiDumpInstance::current(), device, renderPass, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyRenderPass(api_dump, device, renderPass, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRenderAreaGranularity", "device, renderPass, pGranularity", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRenderAreaGranularity<Format>(ApiDumpInstance::current(), device, renderPass, pGranularity);
+    dump_function_head(api_dump, "vkGetRenderAreaGranularity", "device, renderPass, pGranularity", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRenderAreaGranularity(api_dump, device, renderPass, pGranularity);
         }
     }
     device_dispatch_table(device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRenderAreaGranularity<Format>(ApiDumpInstance::current(), device, renderPass, pGranularity);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRenderAreaGranularity(api_dump, device, renderPass, pGranularity);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewport", "commandBuffer, firstViewport, viewportCount, pViewports", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewport<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewports);
+    dump_function_head(api_dump, "vkCmdSetViewport", "commandBuffer, firstViewport, viewportCount, pViewports", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewport(api_dump, commandBuffer, firstViewport, viewportCount, pViewports);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewport<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewports);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewport(api_dump, commandBuffer, firstViewport, viewportCount, pViewports);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetScissor", "commandBuffer, firstScissor, scissorCount, pScissors", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetScissor<Format>(ApiDumpInstance::current(), commandBuffer, firstScissor, scissorCount, pScissors);
+    dump_function_head(api_dump, "vkCmdSetScissor", "commandBuffer, firstScissor, scissorCount, pScissors", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetScissor(api_dump, commandBuffer, firstScissor, scissorCount, pScissors);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetScissor<Format>(ApiDumpInstance::current(), commandBuffer, firstScissor, scissorCount, pScissors);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetScissor(api_dump, commandBuffer, firstScissor, scissorCount, pScissors);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineWidth", "commandBuffer, lineWidth", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLineWidth<Format>(ApiDumpInstance::current(), commandBuffer, lineWidth);
+    dump_function_head(api_dump, "vkCmdSetLineWidth", "commandBuffer, lineWidth", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLineWidth(api_dump, commandBuffer, lineWidth);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLineWidth<Format>(ApiDumpInstance::current(), commandBuffer, lineWidth);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLineWidth(api_dump, commandBuffer, lineWidth);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBias", "commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBias<Format>(ApiDumpInstance::current(), commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+    dump_function_head(api_dump, "vkCmdSetDepthBias", "commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBias(api_dump, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBias<Format>(ApiDumpInstance::current(), commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBias(api_dump, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetBlendConstants", "commandBuffer, blendConstants", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetBlendConstants<Format>(ApiDumpInstance::current(), commandBuffer, blendConstants);
+    dump_function_head(api_dump, "vkCmdSetBlendConstants", "commandBuffer, blendConstants", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetBlendConstants(api_dump, commandBuffer, blendConstants);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetBlendConstants<Format>(ApiDumpInstance::current(), commandBuffer, blendConstants);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetBlendConstants(api_dump, commandBuffer, blendConstants);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBounds", "commandBuffer, minDepthBounds, maxDepthBounds", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBounds<Format>(ApiDumpInstance::current(), commandBuffer, minDepthBounds, maxDepthBounds);
+    dump_function_head(api_dump, "vkCmdSetDepthBounds", "commandBuffer, minDepthBounds, maxDepthBounds", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBounds(api_dump, commandBuffer, minDepthBounds, maxDepthBounds);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBounds<Format>(ApiDumpInstance::current(), commandBuffer, minDepthBounds, maxDepthBounds);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBounds(api_dump, commandBuffer, minDepthBounds, maxDepthBounds);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilCompareMask", "commandBuffer, faceMask, compareMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilCompareMask<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, compareMask);
+    dump_function_head(api_dump, "vkCmdSetStencilCompareMask", "commandBuffer, faceMask, compareMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilCompareMask(api_dump, commandBuffer, faceMask, compareMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilCompareMask<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, compareMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilCompareMask(api_dump, commandBuffer, faceMask, compareMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilWriteMask", "commandBuffer, faceMask, writeMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilWriteMask<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, writeMask);
+    dump_function_head(api_dump, "vkCmdSetStencilWriteMask", "commandBuffer, faceMask, writeMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilWriteMask(api_dump, commandBuffer, faceMask, writeMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilWriteMask<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, writeMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilWriteMask(api_dump, commandBuffer, faceMask, writeMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilReference", "commandBuffer, faceMask, reference", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilReference<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, reference);
+    dump_function_head(api_dump, "vkCmdSetStencilReference", "commandBuffer, faceMask, reference", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilReference(api_dump, commandBuffer, faceMask, reference);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilReference<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, reference);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilReference(api_dump, commandBuffer, faceMask, reference);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindIndexBuffer", "commandBuffer, buffer, offset, indexType", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindIndexBuffer<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, indexType);
+    dump_function_head(api_dump, "vkCmdBindIndexBuffer", "commandBuffer, buffer, offset, indexType", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindIndexBuffer(api_dump, commandBuffer, buffer, offset, indexType);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindIndexBuffer<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, indexType);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindIndexBuffer(api_dump, commandBuffer, buffer, offset, indexType);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindVertexBuffers", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindVertexBuffers<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+    dump_function_head(api_dump, "vkCmdBindVertexBuffers", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindVertexBuffers(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindVertexBuffers<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindVertexBuffers(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDraw", "commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDraw<Format>(ApiDumpInstance::current(), commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    dump_function_head(api_dump, "vkCmdDraw", "commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDraw(api_dump, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDraw<Format>(ApiDumpInstance::current(), commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDraw(api_dump, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexed", "commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndexed<Format>(ApiDumpInstance::current(), commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+    dump_function_head(api_dump, "vkCmdDrawIndexed", "commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndexed(api_dump, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndexed<Format>(ApiDumpInstance::current(), commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndexed(api_dump, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirect", "commandBuffer, buffer, offset, drawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndirect<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndirect", "commandBuffer, buffer, offset, drawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndirect(api_dump, commandBuffer, buffer, offset, drawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndirect<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndirect(api_dump, commandBuffer, buffer, offset, drawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirect", "commandBuffer, buffer, offset, drawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndexedIndirect<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndexedIndirect", "commandBuffer, buffer, offset, drawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndexedIndirect(api_dump, commandBuffer, buffer, offset, drawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndexedIndirect<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndexedIndirect(api_dump, commandBuffer, buffer, offset, drawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBlitImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBlitImage<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+    dump_function_head(api_dump, "vkCmdBlitImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBlitImage(api_dump, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBlitImage<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBlitImage(api_dump, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdClearDepthStencilImage", "commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdClearDepthStencilImage<Format>(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+    dump_function_head(api_dump, "vkCmdClearDepthStencilImage", "commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdClearDepthStencilImage(api_dump, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
         }
     }
     device_dispatch_table(commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdClearDepthStencilImage<Format>(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdClearDepthStencilImage(api_dump, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdClearAttachments", "commandBuffer, attachmentCount, pAttachments, rectCount, pRects", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdClearAttachments<Format>(ApiDumpInstance::current(), commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    dump_function_head(api_dump, "vkCmdClearAttachments", "commandBuffer, attachmentCount, pAttachments, rectCount, pRects", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdClearAttachments(api_dump, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
         }
     }
     device_dispatch_table(commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdClearAttachments<Format>(ApiDumpInstance::current(), commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdClearAttachments(api_dump, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResolveImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResolveImage<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    dump_function_head(api_dump, "vkCmdResolveImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResolveImage(api_dump, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResolveImage<Format>(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResolveImage(api_dump, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderPass", "commandBuffer, pRenderPassBegin, contents", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginRenderPass<Format>(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, contents);
+    dump_function_head(api_dump, "vkCmdBeginRenderPass", "commandBuffer, pRenderPassBegin, contents", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginRenderPass(api_dump, commandBuffer, pRenderPassBegin, contents);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginRenderPass<Format>(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, contents);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginRenderPass(api_dump, commandBuffer, pRenderPassBegin, contents);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdNextSubpass", "commandBuffer, contents", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdNextSubpass<Format>(ApiDumpInstance::current(), commandBuffer, contents);
+    dump_function_head(api_dump, "vkCmdNextSubpass", "commandBuffer, contents", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdNextSubpass(api_dump, commandBuffer, contents);
         }
     }
     device_dispatch_table(commandBuffer)->CmdNextSubpass(commandBuffer, contents);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdNextSubpass<Format>(ApiDumpInstance::current(), commandBuffer, contents);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdNextSubpass(api_dump, commandBuffer, contents);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderPass", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRenderPass<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdEndRenderPass", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRenderPass(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRenderPass(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRenderPass<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRenderPass(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindBufferMemory2", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindBufferMemory2<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindBufferMemory2", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindBufferMemory2(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindBufferMemory2(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindBufferMemory2<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindBufferMemory2(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindImageMemory2", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindImageMemory2<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindImageMemory2", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindImageMemory2(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindImageMemory2(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindImageMemory2<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindImageMemory2(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupPeerMemoryFeatures", "device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceGroupPeerMemoryFeatures<Format>(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+    dump_function_head(api_dump, "vkGetDeviceGroupPeerMemoryFeatures", "device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceGroupPeerMemoryFeatures(api_dump, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
         }
     }
     device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceGroupPeerMemoryFeatures<Format>(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceGroupPeerMemoryFeatures(api_dump, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDeviceMask", "commandBuffer, deviceMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDeviceMask<Format>(ApiDumpInstance::current(), commandBuffer, deviceMask);
+    dump_function_head(api_dump, "vkCmdSetDeviceMask", "commandBuffer, deviceMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDeviceMask(api_dump, commandBuffer, deviceMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDeviceMask(commandBuffer, deviceMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDeviceMask<Format>(ApiDumpInstance::current(), commandBuffer, deviceMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDeviceMask(api_dump, commandBuffer, deviceMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageMemoryRequirements2", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageMemoryRequirements2<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetImageMemoryRequirements2", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageMemoryRequirements2(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageMemoryRequirements2<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageMemoryRequirements2(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferMemoryRequirements2", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferMemoryRequirements2<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetBufferMemoryRequirements2", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferMemoryRequirements2(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferMemoryRequirements2<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferMemoryRequirements2(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSparseMemoryRequirements2", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSparseMemoryRequirements2<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    dump_function_head(api_dump, "vkGetImageSparseMemoryRequirements2", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSparseMemoryRequirements2(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSparseMemoryRequirements2<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSparseMemoryRequirements2(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkTrimCommandPool", "device, commandPool, flags", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkTrimCommandPool<Format>(ApiDumpInstance::current(), device, commandPool, flags);
+    dump_function_head(api_dump, "vkTrimCommandPool", "device, commandPool, flags", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkTrimCommandPool(api_dump, device, commandPool, flags);
         }
     }
     device_dispatch_table(device)->TrimCommandPool(device, commandPool, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkTrimCommandPool<Format>(ApiDumpInstance::current(), device, commandPool, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkTrimCommandPool(api_dump, device, commandPool, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceQueue2", "device, pQueueInfo, pQueue", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceQueue2<Format>(ApiDumpInstance::current(), device, pQueueInfo, pQueue);
+    dump_function_head(api_dump, "vkGetDeviceQueue2", "device, pQueueInfo, pQueue", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceQueue2(api_dump, device, pQueueInfo, pQueue);
         }
     }
     device_dispatch_table(device)->GetDeviceQueue2(device, pQueueInfo, pQueue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceQueue2<Format>(ApiDumpInstance::current(), device, pQueueInfo, pQueue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceQueue2(api_dump, device, pQueueInfo, pQueue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchBase", "commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchBase<Format>(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+    dump_function_head(api_dump, "vkCmdDispatchBase", "commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchBase(api_dump, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchBase<Format>(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchBase(api_dump, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorUpdateTemplate", "device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDescriptorUpdateTemplate<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    dump_function_head(api_dump, "vkCreateDescriptorUpdateTemplate", "device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDescriptorUpdateTemplate(api_dump, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDescriptorUpdateTemplate<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDescriptorUpdateTemplate(api_dump, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorUpdateTemplate", "device, descriptorUpdateTemplate, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDescriptorUpdateTemplate<Format>(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDescriptorUpdateTemplate", "device, descriptorUpdateTemplate, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDescriptorUpdateTemplate(api_dump, device, descriptorUpdateTemplate, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDescriptorUpdateTemplate<Format>(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDescriptorUpdateTemplate(api_dump, device, descriptorUpdateTemplate, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUpdateDescriptorSetWithTemplate", "device, descriptorSet, descriptorUpdateTemplate, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUpdateDescriptorSetWithTemplate<Format>(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData);
+    dump_function_head(api_dump, "vkUpdateDescriptorSetWithTemplate", "device, descriptorSet, descriptorUpdateTemplate, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUpdateDescriptorSetWithTemplate(api_dump, device, descriptorSet, descriptorUpdateTemplate, pData);
         }
     }
     device_dispatch_table(device)->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUpdateDescriptorSetWithTemplate<Format>(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUpdateDescriptorSetWithTemplate(api_dump, device, descriptorSet, descriptorUpdateTemplate, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutSupport", "device, pCreateInfo, pSupport", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorSetLayoutSupport<Format>(ApiDumpInstance::current(), device, pCreateInfo, pSupport);
+    dump_function_head(api_dump, "vkGetDescriptorSetLayoutSupport", "device, pCreateInfo, pSupport", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorSetLayoutSupport(api_dump, device, pCreateInfo, pSupport);
         }
     }
     device_dispatch_table(device)->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorSetLayoutSupport<Format>(ApiDumpInstance::current(), device, pCreateInfo, pSupport);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorSetLayoutSupport(api_dump, device, pCreateInfo, pSupport);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSamplerYcbcrConversion", "device, pCreateInfo, pAllocator, pYcbcrConversion", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSamplerYcbcrConversion<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion);
+    dump_function_head(api_dump, "vkCreateSamplerYcbcrConversion", "device, pCreateInfo, pAllocator, pYcbcrConversion", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSamplerYcbcrConversion(api_dump, device, pCreateInfo, pAllocator, pYcbcrConversion);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSamplerYcbcrConversion<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSamplerYcbcrConversion(api_dump, device, pCreateInfo, pAllocator, pYcbcrConversion);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroySamplerYcbcrConversion", "device, ycbcrConversion, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroySamplerYcbcrConversion<Format>(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator);
+    dump_function_head(api_dump, "vkDestroySamplerYcbcrConversion", "device, ycbcrConversion, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroySamplerYcbcrConversion(api_dump, device, ycbcrConversion, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroySamplerYcbcrConversion<Format>(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroySamplerYcbcrConversion(api_dump, device, ycbcrConversion, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetQueryPool", "device, queryPool, firstQuery, queryCount", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetQueryPool<Format>(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount);
+    dump_function_head(api_dump, "vkResetQueryPool", "device, queryPool, firstQuery, queryCount", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetQueryPool(api_dump, device, queryPool, firstQuery, queryCount);
         }
     }
     device_dispatch_table(device)->ResetQueryPool(device, queryPool, firstQuery, queryCount);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetQueryPool<Format>(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetQueryPool(api_dump, device, queryPool, firstQuery, queryCount);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreCounterValue", "device, semaphore, pValue", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSemaphoreCounterValue<Format>(ApiDumpInstance::current(), device, semaphore, pValue);
+    dump_function_head(api_dump, "vkGetSemaphoreCounterValue", "device, semaphore, pValue", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSemaphoreCounterValue(api_dump, device, semaphore, pValue);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValue(device, semaphore, pValue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSemaphoreCounterValue<Format>(ApiDumpInstance::current(), device, semaphore, pValue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSemaphoreCounterValue(api_dump, device, semaphore, pValue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(device)->WaitSemaphores(device, pWaitInfo, timeout);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkWaitSemaphores", "device, pWaitInfo, timeout", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWaitSemaphores<Format>(ApiDumpInstance::current(), device, pWaitInfo, timeout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkWaitSemaphores", "device, pWaitInfo, timeout", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWaitSemaphores(api_dump, device, pWaitInfo, timeout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSignalSemaphore", "device, pSignalInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSignalSemaphore<Format>(ApiDumpInstance::current(), device, pSignalInfo);
+    dump_function_head(api_dump, "vkSignalSemaphore", "device, pSignalInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSignalSemaphore(api_dump, device, pSignalInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SignalSemaphore(device, pSignalInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSignalSemaphore<Format>(ApiDumpInstance::current(), device, pSignalInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSignalSemaphore(api_dump, device, pSignalInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferDeviceAddress", "device, pInfo", "VkDeviceAddress");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferDeviceAddress<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetBufferDeviceAddress", "device, pInfo", "VkDeviceAddress");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferDeviceAddress(api_dump, device, pInfo);
         }
     }
     VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddress(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferDeviceAddress<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceAddress", result, dump_return_value_VkDeviceAddress);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferDeviceAddress(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferOpaqueCaptureAddress", "device, pInfo", "uint64_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferOpaqueCaptureAddress<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetBufferOpaqueCaptureAddress", "device, pInfo", "uint64_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferOpaqueCaptureAddress(api_dump, device, pInfo);
         }
     }
     uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddress(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint64_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferOpaqueCaptureAddress<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint64_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferOpaqueCaptureAddress(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMemoryOpaqueCaptureAddress", "device, pInfo", "uint64_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceMemoryOpaqueCaptureAddress<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetDeviceMemoryOpaqueCaptureAddress", "device, pInfo", "uint64_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(api_dump, device, pInfo);
         }
     }
     uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint64_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceMemoryOpaqueCaptureAddress<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint64_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectCount", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndirectCount<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndirectCount", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndirectCount(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndirectCount<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndirectCount(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirectCount", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndexedIndirectCount<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndexedIndirectCount", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndexedIndirectCount(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndexedIndirectCount<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndexedIndirectCount(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateRenderPass2", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateRenderPass2<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass);
+    dump_function_head(api_dump, "vkCreateRenderPass2", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateRenderPass2(api_dump, device, pCreateInfo, pAllocator, pRenderPass);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateRenderPass2<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateRenderPass2(api_dump, device, pCreateInfo, pAllocator, pRenderPass);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderPass2", "commandBuffer, pRenderPassBegin, pSubpassBeginInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginRenderPass2<Format>(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+    dump_function_head(api_dump, "vkCmdBeginRenderPass2", "commandBuffer, pRenderPassBegin, pSubpassBeginInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginRenderPass2(api_dump, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginRenderPass2<Format>(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginRenderPass2(api_dump, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdNextSubpass2", "commandBuffer, pSubpassBeginInfo, pSubpassEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdNextSubpass2<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+    dump_function_head(api_dump, "vkCmdNextSubpass2", "commandBuffer, pSubpassBeginInfo, pSubpassEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdNextSubpass2(api_dump, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdNextSubpass2<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdNextSubpass2(api_dump, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderPass2", "commandBuffer, pSubpassEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRenderPass2<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo);
+    dump_function_head(api_dump, "vkCmdEndRenderPass2", "commandBuffer, pSubpassEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRenderPass2(api_dump, commandBuffer, pSubpassEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRenderPass2<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRenderPass2(api_dump, commandBuffer, pSubpassEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreatePrivateDataSlot", "device, pCreateInfo, pAllocator, pPrivateDataSlot", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreatePrivateDataSlot<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot);
+    dump_function_head(api_dump, "vkCreatePrivateDataSlot", "device, pCreateInfo, pAllocator, pPrivateDataSlot", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreatePrivateDataSlot(api_dump, device, pCreateInfo, pAllocator, pPrivateDataSlot);
         }
     }
     VkResult result = device_dispatch_table(device)->CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreatePrivateDataSlot<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreatePrivateDataSlot(api_dump, device, pCreateInfo, pAllocator, pPrivateDataSlot);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyPrivateDataSlot", "device, privateDataSlot, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyPrivateDataSlot<Format>(ApiDumpInstance::current(), device, privateDataSlot, pAllocator);
+    dump_function_head(api_dump, "vkDestroyPrivateDataSlot", "device, privateDataSlot, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyPrivateDataSlot(api_dump, device, privateDataSlot, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyPrivateDataSlot<Format>(ApiDumpInstance::current(), device, privateDataSlot, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyPrivateDataSlot(api_dump, device, privateDataSlot, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetPrivateData", "device, objectType, objectHandle, privateDataSlot, data", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetPrivateData<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data);
+    dump_function_head(api_dump, "vkSetPrivateData", "device, objectType, objectHandle, privateDataSlot, data", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetPrivateData(api_dump, device, objectType, objectHandle, privateDataSlot, data);
         }
     }
     VkResult result = device_dispatch_table(device)->SetPrivateData(device, objectType, objectHandle, privateDataSlot, data);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetPrivateData<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetPrivateData(api_dump, device, objectType, objectHandle, privateDataSlot, data);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPrivateData", "device, objectType, objectHandle, privateDataSlot, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPrivateData<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData);
+    dump_function_head(api_dump, "vkGetPrivateData", "device, objectType, objectHandle, privateDataSlot, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPrivateData(api_dump, device, objectType, objectHandle, privateDataSlot, pData);
         }
     }
     device_dispatch_table(device)->GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPrivateData<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPrivateData(api_dump, device, objectType, objectHandle, privateDataSlot, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPipelineBarrier2", "commandBuffer, pDependencyInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPipelineBarrier2<Format>(ApiDumpInstance::current(), commandBuffer, pDependencyInfo);
+    dump_function_head(api_dump, "vkCmdPipelineBarrier2", "commandBuffer, pDependencyInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPipelineBarrier2(api_dump, commandBuffer, pDependencyInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPipelineBarrier2(commandBuffer, pDependencyInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPipelineBarrier2<Format>(ApiDumpInstance::current(), commandBuffer, pDependencyInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPipelineBarrier2(api_dump, commandBuffer, pDependencyInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteTimestamp2", "commandBuffer, stage, queryPool, query", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteTimestamp2<Format>(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query);
+    dump_function_head(api_dump, "vkCmdWriteTimestamp2", "commandBuffer, stage, queryPool, query", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteTimestamp2(api_dump, commandBuffer, stage, queryPool, query);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteTimestamp2<Format>(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteTimestamp2(api_dump, commandBuffer, stage, queryPool, query);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueSubmit2", "queue, submitCount, pSubmits, fence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueSubmit2<Format>(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence);
+    dump_function_head(api_dump, "vkQueueSubmit2", "queue, submitCount, pSubmits, fence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueSubmit2(api_dump, queue, submitCount, pSubmits, fence);
         }
     }
     VkResult result = device_dispatch_table(queue)->QueueSubmit2(queue, submitCount, pSubmits, fence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueSubmit2<Format>(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueSubmit2(api_dump, queue, submitCount, pSubmits, fence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBuffer2", "commandBuffer, pCopyBufferInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyBuffer2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo);
+    dump_function_head(api_dump, "vkCmdCopyBuffer2", "commandBuffer, pCopyBufferInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyBuffer2(api_dump, commandBuffer, pCopyBufferInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyBuffer2(commandBuffer, pCopyBufferInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyBuffer2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyBuffer2(api_dump, commandBuffer, pCopyBufferInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImage2", "commandBuffer, pCopyImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyImage2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo);
+    dump_function_head(api_dump, "vkCmdCopyImage2", "commandBuffer, pCopyImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyImage2(api_dump, commandBuffer, pCopyImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyImage2(commandBuffer, pCopyImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyImage2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyImage2(api_dump, commandBuffer, pCopyImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBufferToImage2", "commandBuffer, pCopyBufferToImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyBufferToImage2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo);
+    dump_function_head(api_dump, "vkCmdCopyBufferToImage2", "commandBuffer, pCopyBufferToImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyBufferToImage2(api_dump, commandBuffer, pCopyBufferToImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyBufferToImage2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyBufferToImage2(api_dump, commandBuffer, pCopyBufferToImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImageToBuffer2", "commandBuffer, pCopyImageToBufferInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyImageToBuffer2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo);
+    dump_function_head(api_dump, "vkCmdCopyImageToBuffer2", "commandBuffer, pCopyImageToBufferInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyImageToBuffer2(api_dump, commandBuffer, pCopyImageToBufferInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyImageToBuffer2<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyImageToBuffer2(api_dump, commandBuffer, pCopyImageToBufferInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceBufferMemoryRequirements", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceBufferMemoryRequirements<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceBufferMemoryRequirements", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceBufferMemoryRequirements(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceBufferMemoryRequirements<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceBufferMemoryRequirements(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageMemoryRequirements", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceImageMemoryRequirements<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceImageMemoryRequirements", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceImageMemoryRequirements(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceImageMemoryRequirements<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceImageMemoryRequirements(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSparseMemoryRequirements", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceImageSparseMemoryRequirements<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceImageSparseMemoryRequirements", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceImageSparseMemoryRequirements(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceImageSparseMemoryRequirements<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceImageSparseMemoryRequirements(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetEvent2", "commandBuffer, event, pDependencyInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetEvent2<Format>(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo);
+    dump_function_head(api_dump, "vkCmdSetEvent2", "commandBuffer, event, pDependencyInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetEvent2(api_dump, commandBuffer, event, pDependencyInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetEvent2(commandBuffer, event, pDependencyInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetEvent2<Format>(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetEvent2(api_dump, commandBuffer, event, pDependencyInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResetEvent2", "commandBuffer, event, stageMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResetEvent2<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
+    dump_function_head(api_dump, "vkCmdResetEvent2", "commandBuffer, event, stageMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResetEvent2(api_dump, commandBuffer, event, stageMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResetEvent2(commandBuffer, event, stageMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResetEvent2<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResetEvent2(api_dump, commandBuffer, event, stageMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWaitEvents2", "commandBuffer, eventCount, pEvents, pDependencyInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWaitEvents2<Format>(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos);
+    dump_function_head(api_dump, "vkCmdWaitEvents2", "commandBuffer, eventCount, pEvents, pDependencyInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWaitEvents2(api_dump, commandBuffer, eventCount, pEvents, pDependencyInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWaitEvents2<Format>(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWaitEvents2(api_dump, commandBuffer, eventCount, pEvents, pDependencyInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBlitImage2", "commandBuffer, pBlitImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBlitImage2<Format>(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo);
+    dump_function_head(api_dump, "vkCmdBlitImage2", "commandBuffer, pBlitImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBlitImage2(api_dump, commandBuffer, pBlitImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBlitImage2(commandBuffer, pBlitImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBlitImage2<Format>(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBlitImage2(api_dump, commandBuffer, pBlitImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResolveImage2", "commandBuffer, pResolveImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResolveImage2<Format>(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo);
+    dump_function_head(api_dump, "vkCmdResolveImage2", "commandBuffer, pResolveImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResolveImage2(api_dump, commandBuffer, pResolveImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResolveImage2(commandBuffer, pResolveImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResolveImage2<Format>(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResolveImage2(api_dump, commandBuffer, pResolveImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRendering", "commandBuffer, pRenderingInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginRendering<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingInfo);
+    dump_function_head(api_dump, "vkCmdBeginRendering", "commandBuffer, pRenderingInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginRendering(api_dump, commandBuffer, pRenderingInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginRendering(commandBuffer, pRenderingInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginRendering<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginRendering(api_dump, commandBuffer, pRenderingInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRendering", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRendering<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdEndRendering", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRendering(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRendering(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRendering<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRendering(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCullMode", "commandBuffer, cullMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCullMode<Format>(ApiDumpInstance::current(), commandBuffer, cullMode);
+    dump_function_head(api_dump, "vkCmdSetCullMode", "commandBuffer, cullMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCullMode(api_dump, commandBuffer, cullMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCullMode(commandBuffer, cullMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCullMode<Format>(ApiDumpInstance::current(), commandBuffer, cullMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCullMode(api_dump, commandBuffer, cullMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetFrontFace", "commandBuffer, frontFace", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetFrontFace<Format>(ApiDumpInstance::current(), commandBuffer, frontFace);
+    dump_function_head(api_dump, "vkCmdSetFrontFace", "commandBuffer, frontFace", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetFrontFace(api_dump, commandBuffer, frontFace);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetFrontFace(commandBuffer, frontFace);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetFrontFace<Format>(ApiDumpInstance::current(), commandBuffer, frontFace);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetFrontFace(api_dump, commandBuffer, frontFace);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveTopology", "commandBuffer, primitiveTopology", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPrimitiveTopology<Format>(ApiDumpInstance::current(), commandBuffer, primitiveTopology);
+    dump_function_head(api_dump, "vkCmdSetPrimitiveTopology", "commandBuffer, primitiveTopology", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPrimitiveTopology(api_dump, commandBuffer, primitiveTopology);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopology(commandBuffer, primitiveTopology);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPrimitiveTopology<Format>(ApiDumpInstance::current(), commandBuffer, primitiveTopology);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPrimitiveTopology(api_dump, commandBuffer, primitiveTopology);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWithCount", "commandBuffer, viewportCount, pViewports", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewportWithCount<Format>(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports);
+    dump_function_head(api_dump, "vkCmdSetViewportWithCount", "commandBuffer, viewportCount, pViewports", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewportWithCount(api_dump, commandBuffer, viewportCount, pViewports);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewportWithCount<Format>(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewportWithCount(api_dump, commandBuffer, viewportCount, pViewports);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetScissorWithCount", "commandBuffer, scissorCount, pScissors", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetScissorWithCount<Format>(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors);
+    dump_function_head(api_dump, "vkCmdSetScissorWithCount", "commandBuffer, scissorCount, pScissors", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetScissorWithCount(api_dump, commandBuffer, scissorCount, pScissors);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetScissorWithCount<Format>(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetScissorWithCount(api_dump, commandBuffer, scissorCount, pScissors);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindVertexBuffers2", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindVertexBuffers2<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+    dump_function_head(api_dump, "vkCmdBindVertexBuffers2", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindVertexBuffers2(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindVertexBuffers2<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindVertexBuffers2(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthTestEnable", "commandBuffer, depthTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthTestEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthTestEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthTestEnable", "commandBuffer, depthTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthTestEnable(api_dump, commandBuffer, depthTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthTestEnable(commandBuffer, depthTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthTestEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthTestEnable(api_dump, commandBuffer, depthTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthWriteEnable", "commandBuffer, depthWriteEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthWriteEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthWriteEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthWriteEnable", "commandBuffer, depthWriteEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthWriteEnable(api_dump, commandBuffer, depthWriteEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthWriteEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthWriteEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthWriteEnable(api_dump, commandBuffer, depthWriteEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthCompareOp", "commandBuffer, depthCompareOp", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthCompareOp<Format>(ApiDumpInstance::current(), commandBuffer, depthCompareOp);
+    dump_function_head(api_dump, "vkCmdSetDepthCompareOp", "commandBuffer, depthCompareOp", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthCompareOp(api_dump, commandBuffer, depthCompareOp);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthCompareOp(commandBuffer, depthCompareOp);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthCompareOp<Format>(ApiDumpInstance::current(), commandBuffer, depthCompareOp);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthCompareOp(api_dump, commandBuffer, depthCompareOp);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBoundsTestEnable", "commandBuffer, depthBoundsTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBoundsTestEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthBoundsTestEnable", "commandBuffer, depthBoundsTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBoundsTestEnable(api_dump, commandBuffer, depthBoundsTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBoundsTestEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBoundsTestEnable(api_dump, commandBuffer, depthBoundsTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilTestEnable", "commandBuffer, stencilTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilTestEnable<Format>(ApiDumpInstance::current(), commandBuffer, stencilTestEnable);
+    dump_function_head(api_dump, "vkCmdSetStencilTestEnable", "commandBuffer, stencilTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilTestEnable(api_dump, commandBuffer, stencilTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilTestEnable(commandBuffer, stencilTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilTestEnable<Format>(ApiDumpInstance::current(), commandBuffer, stencilTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilTestEnable(api_dump, commandBuffer, stencilTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilOp", "commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilOp<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
+    dump_function_head(api_dump, "vkCmdSetStencilOp", "commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilOp(api_dump, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilOp<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilOp(api_dump, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizerDiscardEnable", "commandBuffer, rasterizerDiscardEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRasterizerDiscardEnable<Format>(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable);
+    dump_function_head(api_dump, "vkCmdSetRasterizerDiscardEnable", "commandBuffer, rasterizerDiscardEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRasterizerDiscardEnable(api_dump, commandBuffer, rasterizerDiscardEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRasterizerDiscardEnable<Format>(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRasterizerDiscardEnable(api_dump, commandBuffer, rasterizerDiscardEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBiasEnable", "commandBuffer, depthBiasEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBiasEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthBiasEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthBiasEnable", "commandBuffer, depthBiasEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBiasEnable(api_dump, commandBuffer, depthBiasEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBiasEnable<Format>(ApiDumpInstance::current(), commandBuffer, depthBiasEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBiasEnable(api_dump, commandBuffer, depthBiasEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveRestartEnable", "commandBuffer, primitiveRestartEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPrimitiveRestartEnable<Format>(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable);
+    dump_function_head(api_dump, "vkCmdSetPrimitiveRestartEnable", "commandBuffer, primitiveRestartEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPrimitiveRestartEnable(api_dump, commandBuffer, primitiveRestartEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPrimitiveRestartEnable<Format>(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPrimitiveRestartEnable(api_dump, commandBuffer, primitiveRestartEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkMapMemory2", "device, pMemoryMapInfo, ppData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkMapMemory2<Format>(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData);
+    dump_function_head(api_dump, "vkMapMemory2", "device, pMemoryMapInfo, ppData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkMapMemory2(api_dump, device, pMemoryMapInfo, ppData);
         }
     }
     VkResult result = device_dispatch_table(device)->MapMemory2(device, pMemoryMapInfo, ppData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkMapMemory2<Format>(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkMapMemory2(api_dump, device, pMemoryMapInfo, ppData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUnmapMemory2", "device, pMemoryUnmapInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUnmapMemory2<Format>(ApiDumpInstance::current(), device, pMemoryUnmapInfo);
+    dump_function_head(api_dump, "vkUnmapMemory2", "device, pMemoryUnmapInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUnmapMemory2(api_dump, device, pMemoryUnmapInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->UnmapMemory2(device, pMemoryUnmapInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUnmapMemory2<Format>(ApiDumpInstance::current(), device, pMemoryUnmapInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUnmapMemory2(api_dump, device, pMemoryUnmapInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSubresourceLayout", "device, pInfo, pLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceImageSubresourceLayout<Format>(ApiDumpInstance::current(), device, pInfo, pLayout);
+    dump_function_head(api_dump, "vkGetDeviceImageSubresourceLayout", "device, pInfo, pLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceImageSubresourceLayout(api_dump, device, pInfo, pLayout);
         }
     }
     device_dispatch_table(device)->GetDeviceImageSubresourceLayout(device, pInfo, pLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceImageSubresourceLayout<Format>(ApiDumpInstance::current(), device, pInfo, pLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceImageSubresourceLayout(api_dump, device, pInfo, pLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout2", "device, image, pSubresource, pLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSubresourceLayout2<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
+    dump_function_head(api_dump, "vkGetImageSubresourceLayout2", "device, image, pSubresource, pLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSubresourceLayout2(api_dump, device, image, pSubresource, pLayout);
         }
     }
     device_dispatch_table(device)->GetImageSubresourceLayout2(device, image, pSubresource, pLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSubresourceLayout2<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSubresourceLayout2(api_dump, device, image, pSubresource, pLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToImage", "device, pCopyMemoryToImageInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyMemoryToImage<Format>(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo);
+    dump_function_head(api_dump, "vkCopyMemoryToImage", "device, pCopyMemoryToImageInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyMemoryToImage(api_dump, device, pCopyMemoryToImageInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyMemoryToImage(device, pCopyMemoryToImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyMemoryToImage<Format>(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyMemoryToImage(api_dump, device, pCopyMemoryToImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyImageToMemory", "device, pCopyImageToMemoryInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyImageToMemory<Format>(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo);
+    dump_function_head(api_dump, "vkCopyImageToMemory", "device, pCopyImageToMemoryInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyImageToMemory(api_dump, device, pCopyImageToMemoryInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyImageToMemory(device, pCopyImageToMemoryInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyImageToMemory<Format>(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyImageToMemory(api_dump, device, pCopyImageToMemoryInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyImageToImage", "device, pCopyImageToImageInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyImageToImage<Format>(ApiDumpInstance::current(), device, pCopyImageToImageInfo);
+    dump_function_head(api_dump, "vkCopyImageToImage", "device, pCopyImageToImageInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyImageToImage(api_dump, device, pCopyImageToImageInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyImageToImage(device, pCopyImageToImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyImageToImage<Format>(ApiDumpInstance::current(), device, pCopyImageToImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyImageToImage(api_dump, device, pCopyImageToImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkTransitionImageLayout", "device, transitionCount, pTransitions", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkTransitionImageLayout<Format>(ApiDumpInstance::current(), device, transitionCount, pTransitions);
+    dump_function_head(api_dump, "vkTransitionImageLayout", "device, transitionCount, pTransitions", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkTransitionImageLayout(api_dump, device, transitionCount, pTransitions);
         }
     }
     VkResult result = device_dispatch_table(device)->TransitionImageLayout(device, transitionCount, pTransitions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkTransitionImageLayout<Format>(ApiDumpInstance::current(), device, transitionCount, pTransitions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkTransitionImageLayout(api_dump, device, transitionCount, pTransitions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSet", "commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSet<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSet", "commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSet(api_dump, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSet<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSet(api_dump, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplate", "commandBuffer, descriptorUpdateTemplate, layout, set, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSetWithTemplate<Format>(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSetWithTemplate", "commandBuffer, descriptorUpdateTemplate, layout, set, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSetWithTemplate(api_dump, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSetWithTemplate<Format>(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSetWithTemplate(api_dump, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorSets2", "commandBuffer, pBindDescriptorSetsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindDescriptorSets2<Format>(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo);
+    dump_function_head(api_dump, "vkCmdBindDescriptorSets2", "commandBuffer, pBindDescriptorSetsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindDescriptorSets2(api_dump, commandBuffer, pBindDescriptorSetsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindDescriptorSets2<Format>(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindDescriptorSets2(api_dump, commandBuffer, pBindDescriptorSetsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushConstants2", "commandBuffer, pPushConstantsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushConstants2<Format>(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo);
+    dump_function_head(api_dump, "vkCmdPushConstants2", "commandBuffer, pPushConstantsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushConstants2(api_dump, commandBuffer, pPushConstantsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushConstants2(commandBuffer, pPushConstantsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushConstants2<Format>(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushConstants2(api_dump, commandBuffer, pPushConstantsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSet2", "commandBuffer, pPushDescriptorSetInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSet2<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSet2", "commandBuffer, pPushDescriptorSetInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSet2(api_dump, commandBuffer, pPushDescriptorSetInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSet2<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSet2(api_dump, commandBuffer, pPushDescriptorSetInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplate2", "commandBuffer, pPushDescriptorSetWithTemplateInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSetWithTemplate2<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSetWithTemplate2", "commandBuffer, pPushDescriptorSetWithTemplateInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSetWithTemplate2(api_dump, commandBuffer, pPushDescriptorSetWithTemplateInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2(commandBuffer, pPushDescriptorSetWithTemplateInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSetWithTemplate2<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSetWithTemplate2(api_dump, commandBuffer, pPushDescriptorSetWithTemplateInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStipple", "commandBuffer, lineStippleFactor, lineStipplePattern", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLineStipple<Format>(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern);
+    dump_function_head(api_dump, "vkCmdSetLineStipple", "commandBuffer, lineStippleFactor, lineStipplePattern", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLineStipple(api_dump, commandBuffer, lineStippleFactor, lineStipplePattern);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLineStipple<Format>(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLineStipple(api_dump, commandBuffer, lineStippleFactor, lineStipplePattern);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindIndexBuffer2", "commandBuffer, buffer, offset, size, indexType", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindIndexBuffer2<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType);
+    dump_function_head(api_dump, "vkCmdBindIndexBuffer2", "commandBuffer, buffer, offset, size, indexType", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindIndexBuffer2(api_dump, commandBuffer, buffer, offset, size, indexType);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindIndexBuffer2<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindIndexBuffer2(api_dump, commandBuffer, buffer, offset, size, indexType);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRenderingAreaGranularity", "device, pRenderingAreaInfo, pGranularity", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRenderingAreaGranularity<Format>(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity);
+    dump_function_head(api_dump, "vkGetRenderingAreaGranularity", "device, pRenderingAreaInfo, pGranularity", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRenderingAreaGranularity(api_dump, device, pRenderingAreaInfo, pGranularity);
         }
     }
     device_dispatch_table(device)->GetRenderingAreaGranularity(device, pRenderingAreaInfo, pGranularity);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRenderingAreaGranularity<Format>(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRenderingAreaGranularity(api_dump, device, pRenderingAreaInfo, pGranularity);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingAttachmentLocations", "commandBuffer, pLocationInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRenderingAttachmentLocations<Format>(ApiDumpInstance::current(), commandBuffer, pLocationInfo);
+    dump_function_head(api_dump, "vkCmdSetRenderingAttachmentLocations", "commandBuffer, pLocationInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRenderingAttachmentLocations(api_dump, commandBuffer, pLocationInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRenderingAttachmentLocations<Format>(ApiDumpInstance::current(), commandBuffer, pLocationInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRenderingAttachmentLocations(api_dump, commandBuffer, pLocationInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingInputAttachmentIndices", "commandBuffer, pInputAttachmentIndexInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRenderingInputAttachmentIndices<Format>(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo);
+    dump_function_head(api_dump, "vkCmdSetRenderingInputAttachmentIndices", "commandBuffer, pInputAttachmentIndexInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRenderingInputAttachmentIndices(api_dump, commandBuffer, pInputAttachmentIndexInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRenderingInputAttachmentIndices<Format>(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRenderingInputAttachmentIndices(api_dump, commandBuffer, pInputAttachmentIndexInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSwapchainKHR", "device, pCreateInfo, pAllocator, pSwapchain", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSwapchainKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSwapchain);
+    dump_function_head(api_dump, "vkCreateSwapchainKHR", "device, pCreateInfo, pAllocator, pSwapchain", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSwapchainKHR(api_dump, device, pCreateInfo, pAllocator, pSwapchain);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSwapchainKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSwapchain);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSwapchainKHR(api_dump, device, pCreateInfo, pAllocator, pSwapchain);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroySwapchainKHR", "device, swapchain, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroySwapchainKHR<Format>(ApiDumpInstance::current(), device, swapchain, pAllocator);
+    dump_function_head(api_dump, "vkDestroySwapchainKHR", "device, swapchain, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroySwapchainKHR(api_dump, device, swapchain, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroySwapchainKHR<Format>(ApiDumpInstance::current(), device, swapchain, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroySwapchainKHR(api_dump, device, swapchain, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainImagesKHR", "device, swapchain, pSwapchainImageCount, pSwapchainImages", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSwapchainImagesKHR<Format>(ApiDumpInstance::current(), device, swapchain, pSwapchainImageCount, pSwapchainImages);
+    dump_function_head(api_dump, "vkGetSwapchainImagesKHR", "device, swapchain, pSwapchainImageCount, pSwapchainImages", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSwapchainImagesKHR(api_dump, device, swapchain, pSwapchainImageCount, pSwapchainImages);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSwapchainImagesKHR<Format>(ApiDumpInstance::current(), device, swapchain, pSwapchainImageCount, pSwapchainImages);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSwapchainImagesKHR(api_dump, device, swapchain, pSwapchainImageCount, pSwapchainImages);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireNextImageKHR", "device, swapchain, timeout, semaphore, fence, pImageIndex", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireNextImageKHR<Format>(ApiDumpInstance::current(), device, swapchain, timeout, semaphore, fence, pImageIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkAcquireNextImageKHR", "device, swapchain, timeout, semaphore, fence, pImageIndex", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireNextImageKHR(api_dump, device, swapchain, timeout, semaphore, fence, pImageIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(queue)->QueuePresentKHR(queue, pPresentInfo);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkQueuePresentKHR", "queue, pPresentInfo", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueuePresentKHR<Format>(ApiDumpInstance::current(), queue, pPresentInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkQueuePresentKHR", "queue, pPresentInfo", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueuePresentKHR(api_dump, queue, pPresentInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
-    ApiDumpInstance::current().nextFrame();
+    api_dump.nextFrame();
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupPresentCapabilitiesKHR", "device, pDeviceGroupPresentCapabilities", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceGroupPresentCapabilitiesKHR<Format>(ApiDumpInstance::current(), device, pDeviceGroupPresentCapabilities);
+    dump_function_head(api_dump, "vkGetDeviceGroupPresentCapabilitiesKHR", "device, pDeviceGroupPresentCapabilities", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(api_dump, device, pDeviceGroupPresentCapabilities);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceGroupPresentCapabilitiesKHR<Format>(ApiDumpInstance::current(), device, pDeviceGroupPresentCapabilities);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(api_dump, device, pDeviceGroupPresentCapabilities);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupSurfacePresentModesKHR", "device, surface, pModes", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceGroupSurfacePresentModesKHR<Format>(ApiDumpInstance::current(), device, surface, pModes);
+    dump_function_head(api_dump, "vkGetDeviceGroupSurfacePresentModesKHR", "device, surface, pModes", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceGroupSurfacePresentModesKHR(api_dump, device, surface, pModes);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceGroupSurfacePresentModesKHR<Format>(ApiDumpInstance::current(), device, surface, pModes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceGroupSurfacePresentModesKHR(api_dump, device, surface, pModes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireNextImage2KHR", "device, pAcquireInfo, pImageIndex", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquireNextImage2KHR<Format>(ApiDumpInstance::current(), device, pAcquireInfo, pImageIndex);
+    dump_function_head(api_dump, "vkAcquireNextImage2KHR", "device, pAcquireInfo, pImageIndex", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquireNextImage2KHR(api_dump, device, pAcquireInfo, pImageIndex);
         }
     }
     VkResult result = device_dispatch_table(device)->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireNextImage2KHR<Format>(ApiDumpInstance::current(), device, pAcquireInfo, pImageIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireNextImage2KHR(api_dump, device, pAcquireInfo, pImageIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSharedSwapchainsKHR", "device, swapchainCount, pCreateInfos, pAllocator, pSwapchains", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSharedSwapchainsKHR<Format>(ApiDumpInstance::current(), device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+    dump_function_head(api_dump, "vkCreateSharedSwapchainsKHR", "device, swapchainCount, pCreateInfos, pAllocator, pSwapchains", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSharedSwapchainsKHR(api_dump, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSharedSwapchainsKHR<Format>(ApiDumpInstance::current(), device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSharedSwapchainsKHR(api_dump, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateVideoSessionKHR", "device, pCreateInfo, pAllocator, pVideoSession", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateVideoSessionKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSession);
+    dump_function_head(api_dump, "vkCreateVideoSessionKHR", "device, pCreateInfo, pAllocator, pVideoSession", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateVideoSessionKHR(api_dump, device, pCreateInfo, pAllocator, pVideoSession);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateVideoSessionKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSession);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateVideoSessionKHR(api_dump, device, pCreateInfo, pAllocator, pVideoSession);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyVideoSessionKHR", "device, videoSession, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyVideoSessionKHR<Format>(ApiDumpInstance::current(), device, videoSession, pAllocator);
+    dump_function_head(api_dump, "vkDestroyVideoSessionKHR", "device, videoSession, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyVideoSessionKHR(api_dump, device, videoSession, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyVideoSessionKHR(device, videoSession, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyVideoSessionKHR<Format>(ApiDumpInstance::current(), device, videoSession, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyVideoSessionKHR(api_dump, device, videoSession, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetVideoSessionMemoryRequirementsKHR", "device, videoSession, pMemoryRequirementsCount, pMemoryRequirements", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetVideoSessionMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetVideoSessionMemoryRequirementsKHR", "device, videoSession, pMemoryRequirementsCount, pMemoryRequirements", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetVideoSessionMemoryRequirementsKHR(api_dump, device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
         }
     }
     VkResult result = device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetVideoSessionMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetVideoSessionMemoryRequirementsKHR(api_dump, device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindVideoSessionMemoryKHR", "device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindVideoSessionMemoryKHR<Format>(ApiDumpInstance::current(), device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
+    dump_function_head(api_dump, "vkBindVideoSessionMemoryKHR", "device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindVideoSessionMemoryKHR(api_dump, device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindVideoSessionMemoryKHR<Format>(ApiDumpInstance::current(), device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindVideoSessionMemoryKHR(api_dump, device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateVideoSessionParametersKHR", "device, pCreateInfo, pAllocator, pVideoSessionParameters", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSessionParameters);
+    dump_function_head(api_dump, "vkCreateVideoSessionParametersKHR", "device, pCreateInfo, pAllocator, pVideoSessionParameters", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateVideoSessionParametersKHR(api_dump, device, pCreateInfo, pAllocator, pVideoSessionParameters);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSessionParameters);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateVideoSessionParametersKHR(api_dump, device, pCreateInfo, pAllocator, pVideoSessionParameters);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUpdateVideoSessionParametersKHR", "device, videoSessionParameters, pUpdateInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUpdateVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, videoSessionParameters, pUpdateInfo);
+    dump_function_head(api_dump, "vkUpdateVideoSessionParametersKHR", "device, videoSessionParameters, pUpdateInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUpdateVideoSessionParametersKHR(api_dump, device, videoSessionParameters, pUpdateInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUpdateVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, videoSessionParameters, pUpdateInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUpdateVideoSessionParametersKHR(api_dump, device, videoSessionParameters, pUpdateInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyVideoSessionParametersKHR", "device, videoSessionParameters, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, videoSessionParameters, pAllocator);
+    dump_function_head(api_dump, "vkDestroyVideoSessionParametersKHR", "device, videoSessionParameters, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyVideoSessionParametersKHR(api_dump, device, videoSessionParameters, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, videoSessionParameters, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyVideoSessionParametersKHR(api_dump, device, videoSessionParameters, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginVideoCodingKHR", "commandBuffer, pBeginInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginVideoCodingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pBeginInfo);
+    dump_function_head(api_dump, "vkCmdBeginVideoCodingKHR", "commandBuffer, pBeginInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginVideoCodingKHR(api_dump, commandBuffer, pBeginInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginVideoCodingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pBeginInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginVideoCodingKHR(api_dump, commandBuffer, pBeginInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndVideoCodingKHR", "commandBuffer, pEndCodingInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndVideoCodingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pEndCodingInfo);
+    dump_function_head(api_dump, "vkCmdEndVideoCodingKHR", "commandBuffer, pEndCodingInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndVideoCodingKHR(api_dump, commandBuffer, pEndCodingInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndVideoCodingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pEndCodingInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndVideoCodingKHR(api_dump, commandBuffer, pEndCodingInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdControlVideoCodingKHR", "commandBuffer, pCodingControlInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdControlVideoCodingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pCodingControlInfo);
+    dump_function_head(api_dump, "vkCmdControlVideoCodingKHR", "commandBuffer, pCodingControlInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdControlVideoCodingKHR(api_dump, commandBuffer, pCodingControlInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdControlVideoCodingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pCodingControlInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdControlVideoCodingKHR(api_dump, commandBuffer, pCodingControlInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDecodeVideoKHR", "commandBuffer, pDecodeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDecodeVideoKHR<Format>(ApiDumpInstance::current(), commandBuffer, pDecodeInfo);
+    dump_function_head(api_dump, "vkCmdDecodeVideoKHR", "commandBuffer, pDecodeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDecodeVideoKHR(api_dump, commandBuffer, pDecodeInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDecodeVideoKHR(commandBuffer, pDecodeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDecodeVideoKHR<Format>(ApiDumpInstance::current(), commandBuffer, pDecodeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDecodeVideoKHR(api_dump, commandBuffer, pDecodeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderingKHR", "commandBuffer, pRenderingInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginRenderingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingInfo);
+    dump_function_head(api_dump, "vkCmdBeginRenderingKHR", "commandBuffer, pRenderingInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginRenderingKHR(api_dump, commandBuffer, pRenderingInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginRenderingKHR(commandBuffer, pRenderingInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginRenderingKHR<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginRenderingKHR(api_dump, commandBuffer, pRenderingInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderingKHR", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRenderingKHR<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdEndRenderingKHR", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRenderingKHR(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRenderingKHR(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRenderingKHR<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRenderingKHR(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupPeerMemoryFeaturesKHR", "device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR<Format>(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+    dump_function_head(api_dump, "vkGetDeviceGroupPeerMemoryFeaturesKHR", "device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(api_dump, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
         }
     }
     device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR<Format>(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(api_dump, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDeviceMaskKHR", "commandBuffer, deviceMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDeviceMaskKHR<Format>(ApiDumpInstance::current(), commandBuffer, deviceMask);
+    dump_function_head(api_dump, "vkCmdSetDeviceMaskKHR", "commandBuffer, deviceMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDeviceMaskKHR(api_dump, commandBuffer, deviceMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDeviceMaskKHR(commandBuffer, deviceMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDeviceMaskKHR<Format>(ApiDumpInstance::current(), commandBuffer, deviceMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDeviceMaskKHR(api_dump, commandBuffer, deviceMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchBaseKHR", "commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchBaseKHR<Format>(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+    dump_function_head(api_dump, "vkCmdDispatchBaseKHR", "commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchBaseKHR(api_dump, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchBaseKHR<Format>(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchBaseKHR(api_dump, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkTrimCommandPoolKHR", "device, commandPool, flags", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkTrimCommandPoolKHR<Format>(ApiDumpInstance::current(), device, commandPool, flags);
+    dump_function_head(api_dump, "vkTrimCommandPoolKHR", "device, commandPool, flags", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkTrimCommandPoolKHR(api_dump, device, commandPool, flags);
         }
     }
     device_dispatch_table(device)->TrimCommandPoolKHR(device, commandPool, flags);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkTrimCommandPoolKHR<Format>(ApiDumpInstance::current(), device, commandPool, flags);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkTrimCommandPoolKHR(api_dump, device, commandPool, flags);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle);
+    dump_function_head(api_dump, "vkGetMemoryWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryWin32HandleKHR(api_dump, device, pGetWin32HandleInfo, pHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryWin32HandleKHR(api_dump, device, pGetWin32HandleInfo, pHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryWin32HandlePropertiesKHR", "device, handleType, handle, pMemoryWin32HandleProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryWin32HandlePropertiesKHR<Format>(ApiDumpInstance::current(), device, handleType, handle, pMemoryWin32HandleProperties);
+    dump_function_head(api_dump, "vkGetMemoryWin32HandlePropertiesKHR", "device, handleType, handle, pMemoryWin32HandleProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryWin32HandlePropertiesKHR(api_dump, device, handleType, handle, pMemoryWin32HandleProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryWin32HandlePropertiesKHR<Format>(ApiDumpInstance::current(), device, handleType, handle, pMemoryWin32HandleProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryWin32HandlePropertiesKHR(api_dump, device, handleType, handle, pMemoryWin32HandleProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryFdKHR", "device, pGetFdInfo, pFd", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryFdKHR<Format>(ApiDumpInstance::current(), device, pGetFdInfo, pFd);
+    dump_function_head(api_dump, "vkGetMemoryFdKHR", "device, pGetFdInfo, pFd", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryFdKHR(api_dump, device, pGetFdInfo, pFd);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryFdKHR(device, pGetFdInfo, pFd);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryFdKHR<Format>(ApiDumpInstance::current(), device, pGetFdInfo, pFd);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryFdKHR(api_dump, device, pGetFdInfo, pFd);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryFdPropertiesKHR", "device, handleType, fd, pMemoryFdProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryFdPropertiesKHR<Format>(ApiDumpInstance::current(), device, handleType, fd, pMemoryFdProperties);
+    dump_function_head(api_dump, "vkGetMemoryFdPropertiesKHR", "device, handleType, fd, pMemoryFdProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryFdPropertiesKHR(api_dump, device, handleType, fd, pMemoryFdProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryFdPropertiesKHR<Format>(ApiDumpInstance::current(), device, handleType, fd, pMemoryFdProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryFdPropertiesKHR(api_dump, device, handleType, fd, pMemoryFdProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkImportSemaphoreWin32HandleKHR", "device, pImportSemaphoreWin32HandleInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkImportSemaphoreWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pImportSemaphoreWin32HandleInfo);
+    dump_function_head(api_dump, "vkImportSemaphoreWin32HandleKHR", "device, pImportSemaphoreWin32HandleInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkImportSemaphoreWin32HandleKHR(api_dump, device, pImportSemaphoreWin32HandleInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkImportSemaphoreWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pImportSemaphoreWin32HandleInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkImportSemaphoreWin32HandleKHR(api_dump, device, pImportSemaphoreWin32HandleInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSemaphoreWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle);
+    dump_function_head(api_dump, "vkGetSemaphoreWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSemaphoreWin32HandleKHR(api_dump, device, pGetWin32HandleInfo, pHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSemaphoreWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSemaphoreWin32HandleKHR(api_dump, device, pGetWin32HandleInfo, pHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkImportSemaphoreFdKHR", "device, pImportSemaphoreFdInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkImportSemaphoreFdKHR<Format>(ApiDumpInstance::current(), device, pImportSemaphoreFdInfo);
+    dump_function_head(api_dump, "vkImportSemaphoreFdKHR", "device, pImportSemaphoreFdInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkImportSemaphoreFdKHR(api_dump, device, pImportSemaphoreFdInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkImportSemaphoreFdKHR<Format>(ApiDumpInstance::current(), device, pImportSemaphoreFdInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkImportSemaphoreFdKHR(api_dump, device, pImportSemaphoreFdInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreFdKHR", "device, pGetFdInfo, pFd", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSemaphoreFdKHR<Format>(ApiDumpInstance::current(), device, pGetFdInfo, pFd);
+    dump_function_head(api_dump, "vkGetSemaphoreFdKHR", "device, pGetFdInfo, pFd", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSemaphoreFdKHR(api_dump, device, pGetFdInfo, pFd);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSemaphoreFdKHR<Format>(ApiDumpInstance::current(), device, pGetFdInfo, pFd);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSemaphoreFdKHR(api_dump, device, pGetFdInfo, pFd);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetKHR", "commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSetKHR<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSetKHR", "commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSetKHR(api_dump, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSetKHR<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSetKHR(api_dump, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplateKHR", "commandBuffer, descriptorUpdateTemplate, layout, set, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSetWithTemplateKHR<Format>(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSetWithTemplateKHR", "commandBuffer, descriptorUpdateTemplate, layout, set, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSetWithTemplateKHR(api_dump, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSetWithTemplateKHR<Format>(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSetWithTemplateKHR(api_dump, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorUpdateTemplateKHR", "device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDescriptorUpdateTemplateKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    dump_function_head(api_dump, "vkCreateDescriptorUpdateTemplateKHR", "device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDescriptorUpdateTemplateKHR(api_dump, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDescriptorUpdateTemplateKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDescriptorUpdateTemplateKHR(api_dump, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorUpdateTemplateKHR", "device, descriptorUpdateTemplate, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDescriptorUpdateTemplateKHR<Format>(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDescriptorUpdateTemplateKHR", "device, descriptorUpdateTemplate, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDescriptorUpdateTemplateKHR(api_dump, device, descriptorUpdateTemplate, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDescriptorUpdateTemplateKHR<Format>(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDescriptorUpdateTemplateKHR(api_dump, device, descriptorUpdateTemplate, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUpdateDescriptorSetWithTemplateKHR", "device, descriptorSet, descriptorUpdateTemplate, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUpdateDescriptorSetWithTemplateKHR<Format>(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData);
+    dump_function_head(api_dump, "vkUpdateDescriptorSetWithTemplateKHR", "device, descriptorSet, descriptorUpdateTemplate, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUpdateDescriptorSetWithTemplateKHR(api_dump, device, descriptorSet, descriptorUpdateTemplate, pData);
         }
     }
     device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUpdateDescriptorSetWithTemplateKHR<Format>(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUpdateDescriptorSetWithTemplateKHR(api_dump, device, descriptorSet, descriptorUpdateTemplate, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateRenderPass2KHR", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateRenderPass2KHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass);
+    dump_function_head(api_dump, "vkCreateRenderPass2KHR", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateRenderPass2KHR(api_dump, device, pCreateInfo, pAllocator, pRenderPass);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateRenderPass2KHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateRenderPass2KHR(api_dump, device, pCreateInfo, pAllocator, pRenderPass);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderPass2KHR", "commandBuffer, pRenderPassBegin, pSubpassBeginInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginRenderPass2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+    dump_function_head(api_dump, "vkCmdBeginRenderPass2KHR", "commandBuffer, pRenderPassBegin, pSubpassBeginInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginRenderPass2KHR(api_dump, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginRenderPass2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginRenderPass2KHR(api_dump, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdNextSubpass2KHR", "commandBuffer, pSubpassBeginInfo, pSubpassEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdNextSubpass2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+    dump_function_head(api_dump, "vkCmdNextSubpass2KHR", "commandBuffer, pSubpassBeginInfo, pSubpassEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdNextSubpass2KHR(api_dump, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdNextSubpass2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdNextSubpass2KHR(api_dump, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderPass2KHR", "commandBuffer, pSubpassEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRenderPass2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo);
+    dump_function_head(api_dump, "vkCmdEndRenderPass2KHR", "commandBuffer, pSubpassEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRenderPass2KHR(api_dump, commandBuffer, pSubpassEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRenderPass2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRenderPass2KHR(api_dump, commandBuffer, pSubpassEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainStatusKHR", "device, swapchain", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSwapchainStatusKHR<Format>(ApiDumpInstance::current(), device, swapchain);
+    dump_function_head(api_dump, "vkGetSwapchainStatusKHR", "device, swapchain", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSwapchainStatusKHR(api_dump, device, swapchain);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSwapchainStatusKHR(device, swapchain);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSwapchainStatusKHR<Format>(ApiDumpInstance::current(), device, swapchain);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSwapchainStatusKHR(api_dump, device, swapchain);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkImportFenceWin32HandleKHR", "device, pImportFenceWin32HandleInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkImportFenceWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pImportFenceWin32HandleInfo);
+    dump_function_head(api_dump, "vkImportFenceWin32HandleKHR", "device, pImportFenceWin32HandleInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkImportFenceWin32HandleKHR(api_dump, device, pImportFenceWin32HandleInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkImportFenceWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pImportFenceWin32HandleInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkImportFenceWin32HandleKHR(api_dump, device, pImportFenceWin32HandleInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetFenceWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetFenceWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle);
+    dump_function_head(api_dump, "vkGetFenceWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetFenceWin32HandleKHR(api_dump, device, pGetWin32HandleInfo, pHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetFenceWin32HandleKHR<Format>(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetFenceWin32HandleKHR(api_dump, device, pGetWin32HandleInfo, pHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkImportFenceFdKHR", "device, pImportFenceFdInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkImportFenceFdKHR<Format>(ApiDumpInstance::current(), device, pImportFenceFdInfo);
+    dump_function_head(api_dump, "vkImportFenceFdKHR", "device, pImportFenceFdInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkImportFenceFdKHR(api_dump, device, pImportFenceFdInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ImportFenceFdKHR(device, pImportFenceFdInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkImportFenceFdKHR<Format>(ApiDumpInstance::current(), device, pImportFenceFdInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkImportFenceFdKHR(api_dump, device, pImportFenceFdInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetFenceFdKHR", "device, pGetFdInfo, pFd", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetFenceFdKHR<Format>(ApiDumpInstance::current(), device, pGetFdInfo, pFd);
+    dump_function_head(api_dump, "vkGetFenceFdKHR", "device, pGetFdInfo, pFd", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetFenceFdKHR(api_dump, device, pGetFdInfo, pFd);
         }
     }
     VkResult result = device_dispatch_table(device)->GetFenceFdKHR(device, pGetFdInfo, pFd);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetFenceFdKHR<Format>(ApiDumpInstance::current(), device, pGetFdInfo, pFd);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetFenceFdKHR(api_dump, device, pGetFdInfo, pFd);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireProfilingLockKHR", "device, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquireProfilingLockKHR<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkAcquireProfilingLockKHR", "device, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquireProfilingLockKHR(api_dump, device, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->AcquireProfilingLockKHR(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireProfilingLockKHR<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireProfilingLockKHR(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkReleaseProfilingLockKHR", "device", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleaseProfilingLockKHR<Format>(ApiDumpInstance::current(), device);
+    dump_function_head(api_dump, "vkReleaseProfilingLockKHR", "device", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleaseProfilingLockKHR(api_dump, device);
         }
     }
     device_dispatch_table(device)->ReleaseProfilingLockKHR(device);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleaseProfilingLockKHR<Format>(ApiDumpInstance::current(), device);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleaseProfilingLockKHR(api_dump, device);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageMemoryRequirements2KHR", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageMemoryRequirements2KHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetImageMemoryRequirements2KHR", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageMemoryRequirements2KHR(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageMemoryRequirements2KHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageMemoryRequirements2KHR(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferMemoryRequirements2KHR", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferMemoryRequirements2KHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetBufferMemoryRequirements2KHR", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferMemoryRequirements2KHR(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferMemoryRequirements2KHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferMemoryRequirements2KHR(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSparseMemoryRequirements2KHR", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSparseMemoryRequirements2KHR<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    dump_function_head(api_dump, "vkGetImageSparseMemoryRequirements2KHR", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSparseMemoryRequirements2KHR(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSparseMemoryRequirements2KHR<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSparseMemoryRequirements2KHR(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateSamplerYcbcrConversionKHR", "device, pCreateInfo, pAllocator, pYcbcrConversion", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateSamplerYcbcrConversionKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion);
+    dump_function_head(api_dump, "vkCreateSamplerYcbcrConversionKHR", "device, pCreateInfo, pAllocator, pYcbcrConversion", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateSamplerYcbcrConversionKHR(api_dump, device, pCreateInfo, pAllocator, pYcbcrConversion);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateSamplerYcbcrConversionKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateSamplerYcbcrConversionKHR(api_dump, device, pCreateInfo, pAllocator, pYcbcrConversion);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroySamplerYcbcrConversionKHR", "device, ycbcrConversion, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroySamplerYcbcrConversionKHR<Format>(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator);
+    dump_function_head(api_dump, "vkDestroySamplerYcbcrConversionKHR", "device, ycbcrConversion, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroySamplerYcbcrConversionKHR(api_dump, device, ycbcrConversion, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroySamplerYcbcrConversionKHR<Format>(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroySamplerYcbcrConversionKHR(api_dump, device, ycbcrConversion, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindBufferMemory2KHR", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindBufferMemory2KHR<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindBufferMemory2KHR", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindBufferMemory2KHR(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindBufferMemory2KHR<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindBufferMemory2KHR(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindImageMemory2KHR", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindImageMemory2KHR<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindImageMemory2KHR", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindImageMemory2KHR(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindImageMemory2KHR(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindImageMemory2KHR<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindImageMemory2KHR(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutSupportKHR", "device, pCreateInfo, pSupport", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorSetLayoutSupportKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pSupport);
+    dump_function_head(api_dump, "vkGetDescriptorSetLayoutSupportKHR", "device, pCreateInfo, pSupport", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorSetLayoutSupportKHR(api_dump, device, pCreateInfo, pSupport);
         }
     }
     device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorSetLayoutSupportKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pSupport);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorSetLayoutSupportKHR(api_dump, device, pCreateInfo, pSupport);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectCountKHR", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndirectCountKHR<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndirectCountKHR", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndirectCountKHR(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndirectCountKHR<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndirectCountKHR(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirectCountKHR", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndexedIndirectCountKHR<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndexedIndirectCountKHR", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndexedIndirectCountKHR(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndexedIndirectCountKHR<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndexedIndirectCountKHR(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreCounterValueKHR", "device, semaphore, pValue", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSemaphoreCounterValueKHR<Format>(ApiDumpInstance::current(), device, semaphore, pValue);
+    dump_function_head(api_dump, "vkGetSemaphoreCounterValueKHR", "device, semaphore, pValue", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSemaphoreCounterValueKHR(api_dump, device, semaphore, pValue);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValueKHR(device, semaphore, pValue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSemaphoreCounterValueKHR<Format>(ApiDumpInstance::current(), device, semaphore, pValue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSemaphoreCounterValueKHR(api_dump, device, semaphore, pValue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
+    auto& api_dump = ApiDumpInstance::current();
     VkResult result = device_dispatch_table(device)->WaitSemaphoresKHR(device, pWaitInfo, timeout);
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    dump_function_head(ApiDumpInstance::current(), "vkWaitSemaphoresKHR", "device, pWaitInfo, timeout", "VkResult");
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWaitSemaphoresKHR<Format>(ApiDumpInstance::current(), device, pWaitInfo, timeout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    dump_function_head(api_dump, "vkWaitSemaphoresKHR", "device, pWaitInfo, timeout", "VkResult");
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWaitSemaphoresKHR(api_dump, device, pWaitInfo, timeout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSignalSemaphoreKHR", "device, pSignalInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSignalSemaphoreKHR<Format>(ApiDumpInstance::current(), device, pSignalInfo);
+    dump_function_head(api_dump, "vkSignalSemaphoreKHR", "device, pSignalInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSignalSemaphoreKHR(api_dump, device, pSignalInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SignalSemaphoreKHR(device, pSignalInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSignalSemaphoreKHR<Format>(ApiDumpInstance::current(), device, pSignalInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSignalSemaphoreKHR(api_dump, device, pSignalInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetFragmentShadingRateKHR", "commandBuffer, pFragmentSize, combinerOps", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetFragmentShadingRateKHR<Format>(ApiDumpInstance::current(), commandBuffer, pFragmentSize, combinerOps);
+    dump_function_head(api_dump, "vkCmdSetFragmentShadingRateKHR", "commandBuffer, pFragmentSize, combinerOps", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetFragmentShadingRateKHR(api_dump, commandBuffer, pFragmentSize, combinerOps);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetFragmentShadingRateKHR<Format>(ApiDumpInstance::current(), commandBuffer, pFragmentSize, combinerOps);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetFragmentShadingRateKHR(api_dump, commandBuffer, pFragmentSize, combinerOps);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingAttachmentLocationsKHR", "commandBuffer, pLocationInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRenderingAttachmentLocationsKHR<Format>(ApiDumpInstance::current(), commandBuffer, pLocationInfo);
+    dump_function_head(api_dump, "vkCmdSetRenderingAttachmentLocationsKHR", "commandBuffer, pLocationInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRenderingAttachmentLocationsKHR(api_dump, commandBuffer, pLocationInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRenderingAttachmentLocationsKHR<Format>(ApiDumpInstance::current(), commandBuffer, pLocationInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRenderingAttachmentLocationsKHR(api_dump, commandBuffer, pLocationInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingInputAttachmentIndicesKHR", "commandBuffer, pInputAttachmentIndexInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo);
+    dump_function_head(api_dump, "vkCmdSetRenderingInputAttachmentIndicesKHR", "commandBuffer, pInputAttachmentIndexInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(api_dump, commandBuffer, pInputAttachmentIndexInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(api_dump, commandBuffer, pInputAttachmentIndexInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkWaitForPresentKHR", "device, swapchain, presentId, timeout", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkWaitForPresentKHR<Format>(ApiDumpInstance::current(), device, swapchain, presentId, timeout);
+    dump_function_head(api_dump, "vkWaitForPresentKHR", "device, swapchain, presentId, timeout", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkWaitForPresentKHR(api_dump, device, swapchain, presentId, timeout);
         }
     }
     VkResult result = device_dispatch_table(device)->WaitForPresentKHR(device, swapchain, presentId, timeout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWaitForPresentKHR<Format>(ApiDumpInstance::current(), device, swapchain, presentId, timeout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWaitForPresentKHR(api_dump, device, swapchain, presentId, timeout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferDeviceAddressKHR", "device, pInfo", "VkDeviceAddress");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferDeviceAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetBufferDeviceAddressKHR", "device, pInfo", "VkDeviceAddress");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferDeviceAddressKHR(api_dump, device, pInfo);
         }
     }
     VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressKHR(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferDeviceAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceAddress", result, dump_return_value_VkDeviceAddress);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferDeviceAddressKHR(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferOpaqueCaptureAddressKHR", "device, pInfo", "uint64_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferOpaqueCaptureAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetBufferOpaqueCaptureAddressKHR", "device, pInfo", "uint64_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferOpaqueCaptureAddressKHR(api_dump, device, pInfo);
         }
     }
     uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint64_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferOpaqueCaptureAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint64_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferOpaqueCaptureAddressKHR(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMemoryOpaqueCaptureAddressKHR", "device, pInfo", "uint64_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetDeviceMemoryOpaqueCaptureAddressKHR", "device, pInfo", "uint64_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(api_dump, device, pInfo);
         }
     }
     uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint64_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint64_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDeferredOperationKHR", "device, pAllocator, pDeferredOperation", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDeferredOperationKHR<Format>(ApiDumpInstance::current(), device, pAllocator, pDeferredOperation);
+    dump_function_head(api_dump, "vkCreateDeferredOperationKHR", "device, pAllocator, pDeferredOperation", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDeferredOperationKHR(api_dump, device, pAllocator, pDeferredOperation);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDeferredOperationKHR<Format>(ApiDumpInstance::current(), device, pAllocator, pDeferredOperation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDeferredOperationKHR(api_dump, device, pAllocator, pDeferredOperation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDeferredOperationKHR", "device, operation, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDeferredOperationKHR<Format>(ApiDumpInstance::current(), device, operation, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDeferredOperationKHR", "device, operation, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDeferredOperationKHR(api_dump, device, operation, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDeferredOperationKHR(device, operation, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDeferredOperationKHR<Format>(ApiDumpInstance::current(), device, operation, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDeferredOperationKHR(api_dump, device, operation, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeferredOperationMaxConcurrencyKHR", "device, operation", "uint32_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeferredOperationMaxConcurrencyKHR<Format>(ApiDumpInstance::current(), device, operation);
+    dump_function_head(api_dump, "vkGetDeferredOperationMaxConcurrencyKHR", "device, operation", "uint32_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeferredOperationMaxConcurrencyKHR(api_dump, device, operation);
         }
     }
     uint32_t result = device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR(device, operation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint32_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeferredOperationMaxConcurrencyKHR<Format>(ApiDumpInstance::current(), device, operation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint32_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeferredOperationMaxConcurrencyKHR(api_dump, device, operation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeferredOperationResultKHR", "device, operation", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeferredOperationResultKHR<Format>(ApiDumpInstance::current(), device, operation);
+    dump_function_head(api_dump, "vkGetDeferredOperationResultKHR", "device, operation", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeferredOperationResultKHR(api_dump, device, operation);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDeferredOperationResultKHR(device, operation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeferredOperationResultKHR<Format>(ApiDumpInstance::current(), device, operation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeferredOperationResultKHR(api_dump, device, operation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDeferredOperationJoinKHR", "device, operation", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDeferredOperationJoinKHR<Format>(ApiDumpInstance::current(), device, operation);
+    dump_function_head(api_dump, "vkDeferredOperationJoinKHR", "device, operation", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDeferredOperationJoinKHR(api_dump, device, operation);
         }
     }
     VkResult result = device_dispatch_table(device)->DeferredOperationJoinKHR(device, operation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDeferredOperationJoinKHR<Format>(ApiDumpInstance::current(), device, operation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDeferredOperationJoinKHR(api_dump, device, operation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineExecutablePropertiesKHR", "device, pPipelineInfo, pExecutableCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineExecutablePropertiesKHR<Format>(ApiDumpInstance::current(), device, pPipelineInfo, pExecutableCount, pProperties);
+    dump_function_head(api_dump, "vkGetPipelineExecutablePropertiesKHR", "device, pPipelineInfo, pExecutableCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineExecutablePropertiesKHR(api_dump, device, pPipelineInfo, pExecutableCount, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineExecutablePropertiesKHR<Format>(ApiDumpInstance::current(), device, pPipelineInfo, pExecutableCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineExecutablePropertiesKHR(api_dump, device, pPipelineInfo, pExecutableCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineExecutableStatisticsKHR", "device, pExecutableInfo, pStatisticCount, pStatistics", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineExecutableStatisticsKHR<Format>(ApiDumpInstance::current(), device, pExecutableInfo, pStatisticCount, pStatistics);
+    dump_function_head(api_dump, "vkGetPipelineExecutableStatisticsKHR", "device, pExecutableInfo, pStatisticCount, pStatistics", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineExecutableStatisticsKHR(api_dump, device, pExecutableInfo, pStatisticCount, pStatistics);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineExecutableStatisticsKHR<Format>(ApiDumpInstance::current(), device, pExecutableInfo, pStatisticCount, pStatistics);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineExecutableStatisticsKHR(api_dump, device, pExecutableInfo, pStatisticCount, pStatistics);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineExecutableInternalRepresentationsKHR", "device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineExecutableInternalRepresentationsKHR<Format>(ApiDumpInstance::current(), device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+    dump_function_head(api_dump, "vkGetPipelineExecutableInternalRepresentationsKHR", "device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(api_dump, device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineExecutableInternalRepresentationsKHR<Format>(ApiDumpInstance::current(), device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(api_dump, device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkMapMemory2KHR", "device, pMemoryMapInfo, ppData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkMapMemory2KHR<Format>(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData);
+    dump_function_head(api_dump, "vkMapMemory2KHR", "device, pMemoryMapInfo, ppData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkMapMemory2KHR(api_dump, device, pMemoryMapInfo, ppData);
         }
     }
     VkResult result = device_dispatch_table(device)->MapMemory2KHR(device, pMemoryMapInfo, ppData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkMapMemory2KHR<Format>(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkMapMemory2KHR(api_dump, device, pMemoryMapInfo, ppData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUnmapMemory2KHR", "device, pMemoryUnmapInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUnmapMemory2KHR<Format>(ApiDumpInstance::current(), device, pMemoryUnmapInfo);
+    dump_function_head(api_dump, "vkUnmapMemory2KHR", "device, pMemoryUnmapInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUnmapMemory2KHR(api_dump, device, pMemoryUnmapInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->UnmapMemory2KHR(device, pMemoryUnmapInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUnmapMemory2KHR<Format>(ApiDumpInstance::current(), device, pMemoryUnmapInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUnmapMemory2KHR(api_dump, device, pMemoryUnmapInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetEncodedVideoSessionParametersKHR", "device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetEncodedVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData);
+    dump_function_head(api_dump, "vkGetEncodedVideoSessionParametersKHR", "device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetEncodedVideoSessionParametersKHR(api_dump, device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetEncodedVideoSessionParametersKHR<Format>(ApiDumpInstance::current(), device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetEncodedVideoSessionParametersKHR(api_dump, device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEncodeVideoKHR", "commandBuffer, pEncodeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEncodeVideoKHR<Format>(ApiDumpInstance::current(), commandBuffer, pEncodeInfo);
+    dump_function_head(api_dump, "vkCmdEncodeVideoKHR", "commandBuffer, pEncodeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEncodeVideoKHR(api_dump, commandBuffer, pEncodeInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEncodeVideoKHR(commandBuffer, pEncodeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEncodeVideoKHR<Format>(ApiDumpInstance::current(), commandBuffer, pEncodeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEncodeVideoKHR(api_dump, commandBuffer, pEncodeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetEvent2KHR", "commandBuffer, event, pDependencyInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetEvent2KHR<Format>(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo);
+    dump_function_head(api_dump, "vkCmdSetEvent2KHR", "commandBuffer, event, pDependencyInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetEvent2KHR(api_dump, commandBuffer, event, pDependencyInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetEvent2KHR<Format>(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetEvent2KHR(api_dump, commandBuffer, event, pDependencyInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResetEvent2KHR", "commandBuffer, event, stageMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResetEvent2KHR<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
+    dump_function_head(api_dump, "vkCmdResetEvent2KHR", "commandBuffer, event, stageMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResetEvent2KHR(api_dump, commandBuffer, event, stageMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResetEvent2KHR(commandBuffer, event, stageMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResetEvent2KHR<Format>(ApiDumpInstance::current(), commandBuffer, event, stageMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResetEvent2KHR(api_dump, commandBuffer, event, stageMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWaitEvents2KHR", "commandBuffer, eventCount, pEvents, pDependencyInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWaitEvents2KHR<Format>(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos);
+    dump_function_head(api_dump, "vkCmdWaitEvents2KHR", "commandBuffer, eventCount, pEvents, pDependencyInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWaitEvents2KHR(api_dump, commandBuffer, eventCount, pEvents, pDependencyInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWaitEvents2KHR<Format>(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWaitEvents2KHR(api_dump, commandBuffer, eventCount, pEvents, pDependencyInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPipelineBarrier2KHR", "commandBuffer, pDependencyInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPipelineBarrier2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pDependencyInfo);
+    dump_function_head(api_dump, "vkCmdPipelineBarrier2KHR", "commandBuffer, pDependencyInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPipelineBarrier2KHR(api_dump, commandBuffer, pDependencyInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPipelineBarrier2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pDependencyInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPipelineBarrier2KHR(api_dump, commandBuffer, pDependencyInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteTimestamp2KHR", "commandBuffer, stage, queryPool, query", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteTimestamp2KHR<Format>(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query);
+    dump_function_head(api_dump, "vkCmdWriteTimestamp2KHR", "commandBuffer, stage, queryPool, query", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteTimestamp2KHR(api_dump, commandBuffer, stage, queryPool, query);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteTimestamp2KHR<Format>(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteTimestamp2KHR(api_dump, commandBuffer, stage, queryPool, query);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueSubmit2KHR", "queue, submitCount, pSubmits, fence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueSubmit2KHR<Format>(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence);
+    dump_function_head(api_dump, "vkQueueSubmit2KHR", "queue, submitCount, pSubmits, fence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueSubmit2KHR(api_dump, queue, submitCount, pSubmits, fence);
         }
     }
     VkResult result = device_dispatch_table(queue)->QueueSubmit2KHR(queue, submitCount, pSubmits, fence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueSubmit2KHR<Format>(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueSubmit2KHR(api_dump, queue, submitCount, pSubmits, fence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBuffer2KHR", "commandBuffer, pCopyBufferInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyBuffer2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo);
+    dump_function_head(api_dump, "vkCmdCopyBuffer2KHR", "commandBuffer, pCopyBufferInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyBuffer2KHR(api_dump, commandBuffer, pCopyBufferInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyBuffer2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyBuffer2KHR(api_dump, commandBuffer, pCopyBufferInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImage2KHR", "commandBuffer, pCopyImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo);
+    dump_function_head(api_dump, "vkCmdCopyImage2KHR", "commandBuffer, pCopyImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyImage2KHR(api_dump, commandBuffer, pCopyImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyImage2KHR(api_dump, commandBuffer, pCopyImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBufferToImage2KHR", "commandBuffer, pCopyBufferToImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyBufferToImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo);
+    dump_function_head(api_dump, "vkCmdCopyBufferToImage2KHR", "commandBuffer, pCopyBufferToImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyBufferToImage2KHR(api_dump, commandBuffer, pCopyBufferToImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyBufferToImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyBufferToImage2KHR(api_dump, commandBuffer, pCopyBufferToImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImageToBuffer2KHR", "commandBuffer, pCopyImageToBufferInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyImageToBuffer2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo);
+    dump_function_head(api_dump, "vkCmdCopyImageToBuffer2KHR", "commandBuffer, pCopyImageToBufferInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyImageToBuffer2KHR(api_dump, commandBuffer, pCopyImageToBufferInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyImageToBuffer2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyImageToBuffer2KHR(api_dump, commandBuffer, pCopyImageToBufferInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBlitImage2KHR", "commandBuffer, pBlitImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBlitImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo);
+    dump_function_head(api_dump, "vkCmdBlitImage2KHR", "commandBuffer, pBlitImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBlitImage2KHR(api_dump, commandBuffer, pBlitImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBlitImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBlitImage2KHR(api_dump, commandBuffer, pBlitImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdResolveImage2KHR", "commandBuffer, pResolveImageInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdResolveImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo);
+    dump_function_head(api_dump, "vkCmdResolveImage2KHR", "commandBuffer, pResolveImageInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdResolveImage2KHR(api_dump, commandBuffer, pResolveImageInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdResolveImage2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdResolveImage2KHR(api_dump, commandBuffer, pResolveImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysIndirect2KHR", "commandBuffer, indirectDeviceAddress", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdTraceRaysIndirect2KHR<Format>(ApiDumpInstance::current(), commandBuffer, indirectDeviceAddress);
+    dump_function_head(api_dump, "vkCmdTraceRaysIndirect2KHR", "commandBuffer, indirectDeviceAddress", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdTraceRaysIndirect2KHR(api_dump, commandBuffer, indirectDeviceAddress);
         }
     }
     device_dispatch_table(commandBuffer)->CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdTraceRaysIndirect2KHR<Format>(ApiDumpInstance::current(), commandBuffer, indirectDeviceAddress);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdTraceRaysIndirect2KHR(api_dump, commandBuffer, indirectDeviceAddress);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceBufferMemoryRequirementsKHR", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceBufferMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceBufferMemoryRequirementsKHR", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceBufferMemoryRequirementsKHR(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceBufferMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceBufferMemoryRequirementsKHR(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageMemoryRequirementsKHR", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceImageMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceImageMemoryRequirementsKHR", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceImageMemoryRequirementsKHR(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceImageMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceImageMemoryRequirementsKHR(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSparseMemoryRequirementsKHR", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceImageSparseMemoryRequirementsKHR", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR<Format>(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(api_dump, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindIndexBuffer2KHR", "commandBuffer, buffer, offset, size, indexType", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindIndexBuffer2KHR<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType);
+    dump_function_head(api_dump, "vkCmdBindIndexBuffer2KHR", "commandBuffer, buffer, offset, size, indexType", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindIndexBuffer2KHR(api_dump, commandBuffer, buffer, offset, size, indexType);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindIndexBuffer2KHR<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindIndexBuffer2KHR(api_dump, commandBuffer, buffer, offset, size, indexType);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRenderingAreaGranularityKHR", "device, pRenderingAreaInfo, pGranularity", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRenderingAreaGranularityKHR<Format>(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity);
+    dump_function_head(api_dump, "vkGetRenderingAreaGranularityKHR", "device, pRenderingAreaInfo, pGranularity", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRenderingAreaGranularityKHR(api_dump, device, pRenderingAreaInfo, pGranularity);
         }
     }
     device_dispatch_table(device)->GetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRenderingAreaGranularityKHR<Format>(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRenderingAreaGranularityKHR(api_dump, device, pRenderingAreaInfo, pGranularity);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSubresourceLayoutKHR", "device, pInfo, pLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceImageSubresourceLayoutKHR<Format>(ApiDumpInstance::current(), device, pInfo, pLayout);
+    dump_function_head(api_dump, "vkGetDeviceImageSubresourceLayoutKHR", "device, pInfo, pLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceImageSubresourceLayoutKHR(api_dump, device, pInfo, pLayout);
         }
     }
     device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceImageSubresourceLayoutKHR<Format>(ApiDumpInstance::current(), device, pInfo, pLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceImageSubresourceLayoutKHR(api_dump, device, pInfo, pLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout2KHR", "device, image, pSubresource, pLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSubresourceLayout2KHR<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
+    dump_function_head(api_dump, "vkGetImageSubresourceLayout2KHR", "device, image, pSubresource, pLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSubresourceLayout2KHR(api_dump, device, image, pSubresource, pLayout);
         }
     }
     device_dispatch_table(device)->GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSubresourceLayout2KHR<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSubresourceLayout2KHR(api_dump, device, image, pSubresource, pLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkWaitForPresent2KHR", "device, swapchain, pPresentWait2Info", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkWaitForPresent2KHR<Format>(ApiDumpInstance::current(), device, swapchain, pPresentWait2Info);
+    dump_function_head(api_dump, "vkWaitForPresent2KHR", "device, swapchain, pPresentWait2Info", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkWaitForPresent2KHR(api_dump, device, swapchain, pPresentWait2Info);
         }
     }
     VkResult result = device_dispatch_table(device)->WaitForPresent2KHR(device, swapchain, pPresentWait2Info);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWaitForPresent2KHR<Format>(ApiDumpInstance::current(), device, swapchain, pPresentWait2Info);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWaitForPresent2KHR(api_dump, device, swapchain, pPresentWait2Info);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreatePipelineBinariesKHR", "device, pCreateInfo, pAllocator, pBinaries", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreatePipelineBinariesKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBinaries);
+    dump_function_head(api_dump, "vkCreatePipelineBinariesKHR", "device, pCreateInfo, pAllocator, pBinaries", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreatePipelineBinariesKHR(api_dump, device, pCreateInfo, pAllocator, pBinaries);
         }
     }
     VkResult result = device_dispatch_table(device)->CreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, pBinaries);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreatePipelineBinariesKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBinaries);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreatePipelineBinariesKHR(api_dump, device, pCreateInfo, pAllocator, pBinaries);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyPipelineBinaryKHR", "device, pipelineBinary, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyPipelineBinaryKHR<Format>(ApiDumpInstance::current(), device, pipelineBinary, pAllocator);
+    dump_function_head(api_dump, "vkDestroyPipelineBinaryKHR", "device, pipelineBinary, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyPipelineBinaryKHR(api_dump, device, pipelineBinary, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyPipelineBinaryKHR<Format>(ApiDumpInstance::current(), device, pipelineBinary, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyPipelineBinaryKHR(api_dump, device, pipelineBinary, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineKeyKHR", "device, pPipelineCreateInfo, pPipelineKey", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineKeyKHR<Format>(ApiDumpInstance::current(), device, pPipelineCreateInfo, pPipelineKey);
+    dump_function_head(api_dump, "vkGetPipelineKeyKHR", "device, pPipelineCreateInfo, pPipelineKey", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineKeyKHR(api_dump, device, pPipelineCreateInfo, pPipelineKey);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelineKeyKHR(device, pPipelineCreateInfo, pPipelineKey);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineKeyKHR<Format>(ApiDumpInstance::current(), device, pPipelineCreateInfo, pPipelineKey);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineKeyKHR(api_dump, device, pPipelineCreateInfo, pPipelineKey);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineBinaryDataKHR", "device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineBinaryDataKHR<Format>(ApiDumpInstance::current(), device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData);
+    dump_function_head(api_dump, "vkGetPipelineBinaryDataKHR", "device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineBinaryDataKHR(api_dump, device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelineBinaryDataKHR(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineBinaryDataKHR<Format>(ApiDumpInstance::current(), device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineBinaryDataKHR(api_dump, device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkReleaseCapturedPipelineDataKHR", "device, pInfo, pAllocator", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleaseCapturedPipelineDataKHR<Format>(ApiDumpInstance::current(), device, pInfo, pAllocator);
+    dump_function_head(api_dump, "vkReleaseCapturedPipelineDataKHR", "device, pInfo, pAllocator", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleaseCapturedPipelineDataKHR(api_dump, device, pInfo, pAllocator);
         }
     }
     VkResult result = device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleaseCapturedPipelineDataKHR<Format>(ApiDumpInstance::current(), device, pInfo, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleaseCapturedPipelineDataKHR(api_dump, device, pInfo, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkReleaseSwapchainImagesKHR", "device, pReleaseInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleaseSwapchainImagesKHR<Format>(ApiDumpInstance::current(), device, pReleaseInfo);
+    dump_function_head(api_dump, "vkReleaseSwapchainImagesKHR", "device, pReleaseInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleaseSwapchainImagesKHR(api_dump, device, pReleaseInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesKHR(device, pReleaseInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleaseSwapchainImagesKHR<Format>(ApiDumpInstance::current(), device, pReleaseInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleaseSwapchainImagesKHR(api_dump, device, pReleaseInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStippleKHR", "commandBuffer, lineStippleFactor, lineStipplePattern", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLineStippleKHR<Format>(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern);
+    dump_function_head(api_dump, "vkCmdSetLineStippleKHR", "commandBuffer, lineStippleFactor, lineStipplePattern", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLineStippleKHR(api_dump, commandBuffer, lineStippleFactor, lineStipplePattern);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLineStippleKHR<Format>(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLineStippleKHR(api_dump, commandBuffer, lineStippleFactor, lineStipplePattern);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetCalibratedTimestampsKHR", "device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetCalibratedTimestampsKHR<Format>(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
+    dump_function_head(api_dump, "vkGetCalibratedTimestampsKHR", "device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetCalibratedTimestampsKHR(api_dump, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
         }
     }
     VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetCalibratedTimestampsKHR<Format>(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetCalibratedTimestampsKHR(api_dump, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorSets2KHR", "commandBuffer, pBindDescriptorSetsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindDescriptorSets2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo);
+    dump_function_head(api_dump, "vkCmdBindDescriptorSets2KHR", "commandBuffer, pBindDescriptorSetsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindDescriptorSets2KHR(api_dump, commandBuffer, pBindDescriptorSetsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindDescriptorSets2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindDescriptorSets2KHR(api_dump, commandBuffer, pBindDescriptorSetsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushConstants2KHR", "commandBuffer, pPushConstantsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushConstants2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo);
+    dump_function_head(api_dump, "vkCmdPushConstants2KHR", "commandBuffer, pPushConstantsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushConstants2KHR(api_dump, commandBuffer, pPushConstantsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushConstants2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushConstants2KHR(api_dump, commandBuffer, pPushConstantsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSet2KHR", "commandBuffer, pPushDescriptorSetInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSet2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSet2KHR", "commandBuffer, pPushDescriptorSetInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSet2KHR(api_dump, commandBuffer, pPushDescriptorSetInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSet2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSet2KHR(api_dump, commandBuffer, pPushDescriptorSetInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplate2KHR", "commandBuffer, pPushDescriptorSetWithTemplateInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDescriptorSetWithTemplate2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo);
+    dump_function_head(api_dump, "vkCmdPushDescriptorSetWithTemplate2KHR", "commandBuffer, pPushDescriptorSetWithTemplateInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(api_dump, commandBuffer, pPushDescriptorSetWithTemplateInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDescriptorSetWithTemplate2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(api_dump, commandBuffer, pPushDescriptorSetWithTemplateInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDescriptorBufferOffsets2EXT", "commandBuffer, pSetDescriptorBufferOffsetsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDescriptorBufferOffsets2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pSetDescriptorBufferOffsetsInfo);
+    dump_function_head(api_dump, "vkCmdSetDescriptorBufferOffsets2EXT", "commandBuffer, pSetDescriptorBufferOffsetsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDescriptorBufferOffsets2EXT(api_dump, commandBuffer, pSetDescriptorBufferOffsetsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDescriptorBufferOffsets2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pSetDescriptorBufferOffsetsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDescriptorBufferOffsets2EXT(api_dump, commandBuffer, pSetDescriptorBufferOffsetsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", "commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo);
+    dump_function_head(api_dump, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", "commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(api_dump, commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(api_dump, commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryIndirectKHR", "commandBuffer, pCopyMemoryIndirectInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMemoryIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyMemoryIndirectInfo);
+    dump_function_head(api_dump, "vkCmdCopyMemoryIndirectKHR", "commandBuffer, pCopyMemoryIndirectInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMemoryIndirectKHR(api_dump, commandBuffer, pCopyMemoryIndirectInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMemoryIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyMemoryIndirectInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMemoryIndirectKHR(api_dump, commandBuffer, pCopyMemoryIndirectInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToImageIndirectKHR", "commandBuffer, pCopyMemoryToImageIndirectInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMemoryToImageIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyMemoryToImageIndirectInfo);
+    dump_function_head(api_dump, "vkCmdCopyMemoryToImageIndirectKHR", "commandBuffer, pCopyMemoryToImageIndirectInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMemoryToImageIndirectKHR(api_dump, commandBuffer, pCopyMemoryToImageIndirectInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMemoryToImageIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, pCopyMemoryToImageIndirectInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMemoryToImageIndirectKHR(api_dump, commandBuffer, pCopyMemoryToImageIndirectInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRendering2KHR", "commandBuffer, pRenderingEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRendering2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo);
+    dump_function_head(api_dump, "vkCmdEndRendering2KHR", "commandBuffer, pRenderingEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRendering2KHR(api_dump, commandBuffer, pRenderingEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRendering2KHR(commandBuffer, pRenderingEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRendering2KHR<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRendering2KHR(api_dump, commandBuffer, pRenderingEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDebugMarkerSetObjectTagEXT", "device, pTagInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDebugMarkerSetObjectTagEXT<Format>(ApiDumpInstance::current(), device, pTagInfo);
+    dump_function_head(api_dump, "vkDebugMarkerSetObjectTagEXT", "device, pTagInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDebugMarkerSetObjectTagEXT(api_dump, device, pTagInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectTagEXT(device, pTagInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDebugMarkerSetObjectTagEXT<Format>(ApiDumpInstance::current(), device, pTagInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDebugMarkerSetObjectTagEXT(api_dump, device, pTagInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    ApiDumpInstance::current().update_object_name_map(pNameInfo);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    api_dump.update_object_name_map(pNameInfo);
 
-    dump_function_head(ApiDumpInstance::current(), "vkDebugMarkerSetObjectNameEXT", "device, pNameInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDebugMarkerSetObjectNameEXT<Format>(ApiDumpInstance::current(), device, pNameInfo);
+    dump_function_head(api_dump, "vkDebugMarkerSetObjectNameEXT", "device, pNameInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDebugMarkerSetObjectNameEXT(api_dump, device, pNameInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectNameEXT(device, pNameInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDebugMarkerSetObjectNameEXT<Format>(ApiDumpInstance::current(), device, pNameInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDebugMarkerSetObjectNameEXT(api_dump, device, pNameInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDebugMarkerBeginEXT", "commandBuffer, pMarkerInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDebugMarkerBeginEXT<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
+    dump_function_head(api_dump, "vkCmdDebugMarkerBeginEXT", "commandBuffer, pMarkerInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDebugMarkerBeginEXT(api_dump, commandBuffer, pMarkerInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDebugMarkerBeginEXT<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDebugMarkerBeginEXT(api_dump, commandBuffer, pMarkerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDebugMarkerEndEXT", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDebugMarkerEndEXT<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdDebugMarkerEndEXT", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDebugMarkerEndEXT(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDebugMarkerEndEXT<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDebugMarkerEndEXT(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDebugMarkerInsertEXT", "commandBuffer, pMarkerInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDebugMarkerInsertEXT<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
+    dump_function_head(api_dump, "vkCmdDebugMarkerInsertEXT", "commandBuffer, pMarkerInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDebugMarkerInsertEXT(api_dump, commandBuffer, pMarkerInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDebugMarkerInsertEXT<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDebugMarkerInsertEXT(api_dump, commandBuffer, pMarkerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindTransformFeedbackBuffersEXT", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindTransformFeedbackBuffersEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
+    dump_function_head(api_dump, "vkCmdBindTransformFeedbackBuffersEXT", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindTransformFeedbackBuffersEXT(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindTransformFeedbackBuffersEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindTransformFeedbackBuffersEXT(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginTransformFeedbackEXT", "commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginTransformFeedbackEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+    dump_function_head(api_dump, "vkCmdBeginTransformFeedbackEXT", "commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginTransformFeedbackEXT(api_dump, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginTransformFeedbackEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginTransformFeedbackEXT(api_dump, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndTransformFeedbackEXT", "commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndTransformFeedbackEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+    dump_function_head(api_dump, "vkCmdEndTransformFeedbackEXT", "commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndTransformFeedbackEXT(api_dump, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndTransformFeedbackEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndTransformFeedbackEXT(api_dump, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginQueryIndexedEXT", "commandBuffer, queryPool, query, flags, index", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginQueryIndexedEXT<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags, index);
+    dump_function_head(api_dump, "vkCmdBeginQueryIndexedEXT", "commandBuffer, queryPool, query, flags, index", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginQueryIndexedEXT(api_dump, commandBuffer, queryPool, query, flags, index);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginQueryIndexedEXT<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags, index);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginQueryIndexedEXT(api_dump, commandBuffer, queryPool, query, flags, index);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndQueryIndexedEXT", "commandBuffer, queryPool, query, index", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndQueryIndexedEXT<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query, index);
+    dump_function_head(api_dump, "vkCmdEndQueryIndexedEXT", "commandBuffer, queryPool, query, index", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndQueryIndexedEXT(api_dump, commandBuffer, queryPool, query, index);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndQueryIndexedEXT<Format>(ApiDumpInstance::current(), commandBuffer, queryPool, query, index);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndQueryIndexedEXT(api_dump, commandBuffer, queryPool, query, index);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectByteCountEXT", "commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndirectByteCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
+    dump_function_head(api_dump, "vkCmdDrawIndirectByteCountEXT", "commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndirectByteCountEXT(api_dump, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndirectByteCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndirectByteCountEXT(api_dump, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateCuModuleNVX", "device, pCreateInfo, pAllocator, pModule", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateCuModuleNVX<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule);
+    dump_function_head(api_dump, "vkCreateCuModuleNVX", "device, pCreateInfo, pAllocator, pModule", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateCuModuleNVX(api_dump, device, pCreateInfo, pAllocator, pModule);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateCuModuleNVX<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateCuModuleNVX(api_dump, device, pCreateInfo, pAllocator, pModule);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateCuFunctionNVX", "device, pCreateInfo, pAllocator, pFunction", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateCuFunctionNVX<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction);
+    dump_function_head(api_dump, "vkCreateCuFunctionNVX", "device, pCreateInfo, pAllocator, pFunction", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateCuFunctionNVX(api_dump, device, pCreateInfo, pAllocator, pFunction);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateCuFunctionNVX<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateCuFunctionNVX(api_dump, device, pCreateInfo, pAllocator, pFunction);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyCuModuleNVX", "device, module, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyCuModuleNVX<Format>(ApiDumpInstance::current(), device, module, pAllocator);
+    dump_function_head(api_dump, "vkDestroyCuModuleNVX", "device, module, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyCuModuleNVX(api_dump, device, module, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyCuModuleNVX(device, module, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyCuModuleNVX<Format>(ApiDumpInstance::current(), device, module, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyCuModuleNVX(api_dump, device, module, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyCuFunctionNVX", "device, function, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyCuFunctionNVX<Format>(ApiDumpInstance::current(), device, function, pAllocator);
+    dump_function_head(api_dump, "vkDestroyCuFunctionNVX", "device, function, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyCuFunctionNVX(api_dump, device, function, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyCuFunctionNVX(device, function, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyCuFunctionNVX<Format>(ApiDumpInstance::current(), device, function, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyCuFunctionNVX(api_dump, device, function, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCuLaunchKernelNVX", "commandBuffer, pLaunchInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCuLaunchKernelNVX<Format>(ApiDumpInstance::current(), commandBuffer, pLaunchInfo);
+    dump_function_head(api_dump, "vkCmdCuLaunchKernelNVX", "commandBuffer, pLaunchInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCuLaunchKernelNVX(api_dump, commandBuffer, pLaunchInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCuLaunchKernelNVX<Format>(ApiDumpInstance::current(), commandBuffer, pLaunchInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCuLaunchKernelNVX(api_dump, commandBuffer, pLaunchInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageViewHandleNVX", "device, pInfo", "uint32_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageViewHandleNVX<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetImageViewHandleNVX", "device, pInfo", "uint32_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageViewHandleNVX(api_dump, device, pInfo);
         }
     }
     uint32_t result = device_dispatch_table(device)->GetImageViewHandleNVX(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint32_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageViewHandleNVX<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint32_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageViewHandleNVX(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageViewHandle64NVX", "device, pInfo", "uint64_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageViewHandle64NVX<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetImageViewHandle64NVX", "device, pInfo", "uint64_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageViewHandle64NVX(api_dump, device, pInfo);
         }
     }
     uint64_t result = device_dispatch_table(device)->GetImageViewHandle64NVX(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint64_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageViewHandle64NVX<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint64_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageViewHandle64NVX(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageViewAddressNVX", "device, imageView, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageViewAddressNVX<Format>(ApiDumpInstance::current(), device, imageView, pProperties);
+    dump_function_head(api_dump, "vkGetImageViewAddressNVX", "device, imageView, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageViewAddressNVX(api_dump, device, imageView, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetImageViewAddressNVX(device, imageView, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageViewAddressNVX<Format>(ApiDumpInstance::current(), device, imageView, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageViewAddressNVX(api_dump, device, imageView, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceCombinedImageSamplerIndexNVX", "device, imageViewIndex, samplerIndex", "uint64_t");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceCombinedImageSamplerIndexNVX<Format>(ApiDumpInstance::current(), device, imageViewIndex, samplerIndex);
+    dump_function_head(api_dump, "vkGetDeviceCombinedImageSamplerIndexNVX", "device, imageViewIndex, samplerIndex", "uint64_t");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(api_dump, device, imageViewIndex, samplerIndex);
         }
     }
     uint64_t result = device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX(device, imageViewIndex, samplerIndex);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "uint64_t", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceCombinedImageSamplerIndexNVX<Format>(ApiDumpInstance::current(), device, imageViewIndex, samplerIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "uint64_t", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(api_dump, device, imageViewIndex, samplerIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectCountAMD", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndirectCountAMD<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndirectCountAMD", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndirectCountAMD(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndirectCountAMD<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndirectCountAMD(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirectCountAMD", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawIndexedIndirectCountAMD<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawIndexedIndirectCountAMD", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawIndexedIndirectCountAMD(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawIndexedIndirectCountAMD<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawIndexedIndirectCountAMD(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetShaderInfoAMD", "device, pipeline, shaderStage, infoType, pInfoSize, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetShaderInfoAMD<Format>(ApiDumpInstance::current(), device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
+    dump_function_head(api_dump, "vkGetShaderInfoAMD", "device, pipeline, shaderStage, infoType, pInfoSize, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetShaderInfoAMD(api_dump, device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetShaderInfoAMD<Format>(ApiDumpInstance::current(), device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetShaderInfoAMD(api_dump, device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryWin32HandleNV", "device, memory, handleType, pHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryWin32HandleNV<Format>(ApiDumpInstance::current(), device, memory, handleType, pHandle);
+    dump_function_head(api_dump, "vkGetMemoryWin32HandleNV", "device, memory, handleType, pHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryWin32HandleNV(api_dump, device, memory, handleType, pHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryWin32HandleNV<Format>(ApiDumpInstance::current(), device, memory, handleType, pHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryWin32HandleNV(api_dump, device, memory, handleType, pHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginConditionalRenderingEXT", "commandBuffer, pConditionalRenderingBegin", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginConditionalRenderingEXT<Format>(ApiDumpInstance::current(), commandBuffer, pConditionalRenderingBegin);
+    dump_function_head(api_dump, "vkCmdBeginConditionalRenderingEXT", "commandBuffer, pConditionalRenderingBegin", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginConditionalRenderingEXT(api_dump, commandBuffer, pConditionalRenderingBegin);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginConditionalRenderingEXT<Format>(ApiDumpInstance::current(), commandBuffer, pConditionalRenderingBegin);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginConditionalRenderingEXT(api_dump, commandBuffer, pConditionalRenderingBegin);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndConditionalRenderingEXT", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndConditionalRenderingEXT<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdEndConditionalRenderingEXT", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndConditionalRenderingEXT(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndConditionalRenderingEXT(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndConditionalRenderingEXT<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndConditionalRenderingEXT(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWScalingNV", "commandBuffer, firstViewport, viewportCount, pViewportWScalings", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewportWScalingNV<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportWScalings);
+    dump_function_head(api_dump, "vkCmdSetViewportWScalingNV", "commandBuffer, firstViewport, viewportCount, pViewportWScalings", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewportWScalingNV(api_dump, commandBuffer, firstViewport, viewportCount, pViewportWScalings);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewportWScalingNV<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportWScalings);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewportWScalingNV(api_dump, commandBuffer, firstViewport, viewportCount, pViewportWScalings);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDisplayPowerControlEXT", "device, display, pDisplayPowerInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDisplayPowerControlEXT<Format>(ApiDumpInstance::current(), device, display, pDisplayPowerInfo);
+    dump_function_head(api_dump, "vkDisplayPowerControlEXT", "device, display, pDisplayPowerInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDisplayPowerControlEXT(api_dump, device, display, pDisplayPowerInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDisplayPowerControlEXT<Format>(ApiDumpInstance::current(), device, display, pDisplayPowerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDisplayPowerControlEXT(api_dump, device, display, pDisplayPowerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkRegisterDeviceEventEXT", "device, pDeviceEventInfo, pAllocator, pFence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkRegisterDeviceEventEXT<Format>(ApiDumpInstance::current(), device, pDeviceEventInfo, pAllocator, pFence);
+    dump_function_head(api_dump, "vkRegisterDeviceEventEXT", "device, pDeviceEventInfo, pAllocator, pFence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkRegisterDeviceEventEXT(api_dump, device, pDeviceEventInfo, pAllocator, pFence);
         }
     }
     VkResult result = device_dispatch_table(device)->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkRegisterDeviceEventEXT<Format>(ApiDumpInstance::current(), device, pDeviceEventInfo, pAllocator, pFence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkRegisterDeviceEventEXT(api_dump, device, pDeviceEventInfo, pAllocator, pFence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkRegisterDisplayEventEXT", "device, display, pDisplayEventInfo, pAllocator, pFence", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkRegisterDisplayEventEXT<Format>(ApiDumpInstance::current(), device, display, pDisplayEventInfo, pAllocator, pFence);
+    dump_function_head(api_dump, "vkRegisterDisplayEventEXT", "device, display, pDisplayEventInfo, pAllocator, pFence", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkRegisterDisplayEventEXT(api_dump, device, display, pDisplayEventInfo, pAllocator, pFence);
         }
     }
     VkResult result = device_dispatch_table(device)->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkRegisterDisplayEventEXT<Format>(ApiDumpInstance::current(), device, display, pDisplayEventInfo, pAllocator, pFence);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkRegisterDisplayEventEXT(api_dump, device, display, pDisplayEventInfo, pAllocator, pFence);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainCounterEXT", "device, swapchain, counter, pCounterValue", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSwapchainCounterEXT<Format>(ApiDumpInstance::current(), device, swapchain, counter, pCounterValue);
+    dump_function_head(api_dump, "vkGetSwapchainCounterEXT", "device, swapchain, counter, pCounterValue", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSwapchainCounterEXT(api_dump, device, swapchain, counter, pCounterValue);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSwapchainCounterEXT<Format>(ApiDumpInstance::current(), device, swapchain, counter, pCounterValue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSwapchainCounterEXT(api_dump, device, swapchain, counter, pCounterValue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRefreshCycleDurationGOOGLE", "device, swapchain, pDisplayTimingProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRefreshCycleDurationGOOGLE<Format>(ApiDumpInstance::current(), device, swapchain, pDisplayTimingProperties);
+    dump_function_head(api_dump, "vkGetRefreshCycleDurationGOOGLE", "device, swapchain, pDisplayTimingProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRefreshCycleDurationGOOGLE(api_dump, device, swapchain, pDisplayTimingProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRefreshCycleDurationGOOGLE<Format>(ApiDumpInstance::current(), device, swapchain, pDisplayTimingProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRefreshCycleDurationGOOGLE(api_dump, device, swapchain, pDisplayTimingProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPastPresentationTimingGOOGLE", "device, swapchain, pPresentationTimingCount, pPresentationTimings", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPastPresentationTimingGOOGLE<Format>(ApiDumpInstance::current(), device, swapchain, pPresentationTimingCount, pPresentationTimings);
+    dump_function_head(api_dump, "vkGetPastPresentationTimingGOOGLE", "device, swapchain, pPresentationTimingCount, pPresentationTimings", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPastPresentationTimingGOOGLE(api_dump, device, swapchain, pPresentationTimingCount, pPresentationTimings);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPastPresentationTimingGOOGLE<Format>(ApiDumpInstance::current(), device, swapchain, pPresentationTimingCount, pPresentationTimings);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPastPresentationTimingGOOGLE(api_dump, device, swapchain, pPresentationTimingCount, pPresentationTimings);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDiscardRectangleEXT", "commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDiscardRectangleEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
+    dump_function_head(api_dump, "vkCmdSetDiscardRectangleEXT", "commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDiscardRectangleEXT(api_dump, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDiscardRectangleEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDiscardRectangleEXT(api_dump, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDiscardRectangleEnableEXT", "commandBuffer, discardRectangleEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDiscardRectangleEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, discardRectangleEnable);
+    dump_function_head(api_dump, "vkCmdSetDiscardRectangleEnableEXT", "commandBuffer, discardRectangleEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDiscardRectangleEnableEXT(api_dump, commandBuffer, discardRectangleEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDiscardRectangleEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, discardRectangleEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDiscardRectangleEnableEXT(api_dump, commandBuffer, discardRectangleEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDiscardRectangleModeEXT", "commandBuffer, discardRectangleMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDiscardRectangleModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, discardRectangleMode);
+    dump_function_head(api_dump, "vkCmdSetDiscardRectangleModeEXT", "commandBuffer, discardRectangleMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDiscardRectangleModeEXT(api_dump, commandBuffer, discardRectangleMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDiscardRectangleModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, discardRectangleMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDiscardRectangleModeEXT(api_dump, commandBuffer, discardRectangleMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetHdrMetadataEXT", "device, swapchainCount, pSwapchains, pMetadata", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetHdrMetadataEXT<Format>(ApiDumpInstance::current(), device, swapchainCount, pSwapchains, pMetadata);
+    dump_function_head(api_dump, "vkSetHdrMetadataEXT", "device, swapchainCount, pSwapchains, pMetadata", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetHdrMetadataEXT(api_dump, device, swapchainCount, pSwapchains, pMetadata);
         }
     }
     device_dispatch_table(device)->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetHdrMetadataEXT<Format>(ApiDumpInstance::current(), device, swapchainCount, pSwapchains, pMetadata);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetHdrMetadataEXT(api_dump, device, swapchainCount, pSwapchains, pMetadata);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-    ApiDumpInstance::current().update_object_name_map(pNameInfo);
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+    api_dump.update_object_name_map(pNameInfo);
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetDebugUtilsObjectNameEXT", "device, pNameInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetDebugUtilsObjectNameEXT<Format>(ApiDumpInstance::current(), device, pNameInfo);
+    dump_function_head(api_dump, "vkSetDebugUtilsObjectNameEXT", "device, pNameInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetDebugUtilsObjectNameEXT(api_dump, device, pNameInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectNameEXT(device, pNameInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetDebugUtilsObjectNameEXT<Format>(ApiDumpInstance::current(), device, pNameInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetDebugUtilsObjectNameEXT(api_dump, device, pNameInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetDebugUtilsObjectTagEXT", "device, pTagInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetDebugUtilsObjectTagEXT<Format>(ApiDumpInstance::current(), device, pTagInfo);
+    dump_function_head(api_dump, "vkSetDebugUtilsObjectTagEXT", "device, pTagInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetDebugUtilsObjectTagEXT(api_dump, device, pTagInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectTagEXT(device, pTagInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetDebugUtilsObjectTagEXT<Format>(ApiDumpInstance::current(), device, pTagInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetDebugUtilsObjectTagEXT(api_dump, device, pTagInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueBeginDebugUtilsLabelEXT", "queue, pLabelInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueBeginDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), queue, pLabelInfo);
+    dump_function_head(api_dump, "vkQueueBeginDebugUtilsLabelEXT", "queue, pLabelInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueBeginDebugUtilsLabelEXT(api_dump, queue, pLabelInfo);
         }
     }
     device_dispatch_table(queue)->QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueBeginDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), queue, pLabelInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueBeginDebugUtilsLabelEXT(api_dump, queue, pLabelInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueEndDebugUtilsLabelEXT", "queue", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueEndDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), queue);
+    dump_function_head(api_dump, "vkQueueEndDebugUtilsLabelEXT", "queue", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueEndDebugUtilsLabelEXT(api_dump, queue);
         }
     }
     device_dispatch_table(queue)->QueueEndDebugUtilsLabelEXT(queue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueEndDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), queue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueEndDebugUtilsLabelEXT(api_dump, queue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueInsertDebugUtilsLabelEXT", "queue, pLabelInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueInsertDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), queue, pLabelInfo);
+    dump_function_head(api_dump, "vkQueueInsertDebugUtilsLabelEXT", "queue, pLabelInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueInsertDebugUtilsLabelEXT(api_dump, queue, pLabelInfo);
         }
     }
     device_dispatch_table(queue)->QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueInsertDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), queue, pLabelInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueInsertDebugUtilsLabelEXT(api_dump, queue, pLabelInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginDebugUtilsLabelEXT", "commandBuffer, pLabelInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), commandBuffer, pLabelInfo);
+    dump_function_head(api_dump, "vkCmdBeginDebugUtilsLabelEXT", "commandBuffer, pLabelInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginDebugUtilsLabelEXT(api_dump, commandBuffer, pLabelInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), commandBuffer, pLabelInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginDebugUtilsLabelEXT(api_dump, commandBuffer, pLabelInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndDebugUtilsLabelEXT", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdEndDebugUtilsLabelEXT", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndDebugUtilsLabelEXT(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndDebugUtilsLabelEXT(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndDebugUtilsLabelEXT(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdInsertDebugUtilsLabelEXT", "commandBuffer, pLabelInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdInsertDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), commandBuffer, pLabelInfo);
+    dump_function_head(api_dump, "vkCmdInsertDebugUtilsLabelEXT", "commandBuffer, pLabelInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdInsertDebugUtilsLabelEXT(api_dump, commandBuffer, pLabelInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdInsertDebugUtilsLabelEXT<Format>(ApiDumpInstance::current(), commandBuffer, pLabelInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdInsertDebugUtilsLabelEXT(api_dump, commandBuffer, pLabelInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetAndroidHardwareBufferPropertiesANDROID", "device, buffer, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetAndroidHardwareBufferPropertiesANDROID<Format>(ApiDumpInstance::current(), device, buffer, pProperties);
+    dump_function_head(api_dump, "vkGetAndroidHardwareBufferPropertiesANDROID", "device, buffer, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(api_dump, device, buffer, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetAndroidHardwareBufferPropertiesANDROID<Format>(ApiDumpInstance::current(), device, buffer, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(api_dump, device, buffer, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryAndroidHardwareBufferANDROID", "device, pInfo, pBuffer", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryAndroidHardwareBufferANDROID<Format>(ApiDumpInstance::current(), device, pInfo, pBuffer);
+    dump_function_head(api_dump, "vkGetMemoryAndroidHardwareBufferANDROID", "device, pInfo, pBuffer", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryAndroidHardwareBufferANDROID(api_dump, device, pInfo, pBuffer);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryAndroidHardwareBufferANDROID<Format>(ApiDumpInstance::current(), device, pInfo, pBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryAndroidHardwareBufferANDROID(api_dump, device, pInfo, pBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateExecutionGraphPipelinesAMDX", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateExecutionGraphPipelinesAMDX<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    dump_function_head(api_dump, "vkCreateExecutionGraphPipelinesAMDX", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateExecutionGraphPipelinesAMDX(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateExecutionGraphPipelinesAMDX<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateExecutionGraphPipelinesAMDX(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetExecutionGraphPipelineScratchSizeAMDX", "device, executionGraph, pSizeInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX<Format>(ApiDumpInstance::current(), device, executionGraph, pSizeInfo);
+    dump_function_head(api_dump, "vkGetExecutionGraphPipelineScratchSizeAMDX", "device, executionGraph, pSizeInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(api_dump, device, executionGraph, pSizeInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX<Format>(ApiDumpInstance::current(), device, executionGraph, pSizeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(api_dump, device, executionGraph, pSizeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetExecutionGraphPipelineNodeIndexAMDX", "device, executionGraph, pNodeInfo, pNodeIndex", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX<Format>(ApiDumpInstance::current(), device, executionGraph, pNodeInfo, pNodeIndex);
+    dump_function_head(api_dump, "vkGetExecutionGraphPipelineNodeIndexAMDX", "device, executionGraph, pNodeInfo, pNodeIndex", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(api_dump, device, executionGraph, pNodeInfo, pNodeIndex);
         }
     }
     VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX<Format>(ApiDumpInstance::current(), device, executionGraph, pNodeInfo, pNodeIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(api_dump, device, executionGraph, pNodeInfo, pNodeIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdInitializeGraphScratchMemoryAMDX", "commandBuffer, executionGraph, scratch, scratchSize", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdInitializeGraphScratchMemoryAMDX<Format>(ApiDumpInstance::current(), commandBuffer, executionGraph, scratch, scratchSize);
+    dump_function_head(api_dump, "vkCmdInitializeGraphScratchMemoryAMDX", "commandBuffer, executionGraph, scratch, scratchSize", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdInitializeGraphScratchMemoryAMDX(api_dump, commandBuffer, executionGraph, scratch, scratchSize);
         }
     }
     device_dispatch_table(commandBuffer)->CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdInitializeGraphScratchMemoryAMDX<Format>(ApiDumpInstance::current(), commandBuffer, executionGraph, scratch, scratchSize);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdInitializeGraphScratchMemoryAMDX(api_dump, commandBuffer, executionGraph, scratch, scratchSize);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchGraphAMDX", "commandBuffer, scratch, scratchSize, pCountInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchGraphAMDX<Format>(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo);
+    dump_function_head(api_dump, "vkCmdDispatchGraphAMDX", "commandBuffer, scratch, scratchSize, pCountInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchGraphAMDX(api_dump, commandBuffer, scratch, scratchSize, pCountInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchGraphAMDX(commandBuffer, scratch, scratchSize, pCountInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchGraphAMDX<Format>(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchGraphAMDX(api_dump, commandBuffer, scratch, scratchSize, pCountInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchGraphIndirectAMDX", "commandBuffer, scratch, scratchSize, pCountInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchGraphIndirectAMDX<Format>(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo);
+    dump_function_head(api_dump, "vkCmdDispatchGraphIndirectAMDX", "commandBuffer, scratch, scratchSize, pCountInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchGraphIndirectAMDX(api_dump, commandBuffer, scratch, scratchSize, pCountInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectAMDX(commandBuffer, scratch, scratchSize, pCountInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchGraphIndirectAMDX<Format>(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchGraphIndirectAMDX(api_dump, commandBuffer, scratch, scratchSize, pCountInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchGraphIndirectCountAMDX", "commandBuffer, scratch, scratchSize, countInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchGraphIndirectCountAMDX<Format>(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, countInfo);
+    dump_function_head(api_dump, "vkCmdDispatchGraphIndirectCountAMDX", "commandBuffer, scratch, scratchSize, countInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchGraphIndirectCountAMDX(api_dump, commandBuffer, scratch, scratchSize, countInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, scratchSize, countInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchGraphIndirectCountAMDX<Format>(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, countInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchGraphIndirectCountAMDX(api_dump, commandBuffer, scratch, scratchSize, countInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkWriteSamplerDescriptorsEXT", "device, samplerCount, pSamplers, pDescriptors", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkWriteSamplerDescriptorsEXT<Format>(ApiDumpInstance::current(), device, samplerCount, pSamplers, pDescriptors);
+    dump_function_head(api_dump, "vkWriteSamplerDescriptorsEXT", "device, samplerCount, pSamplers, pDescriptors", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkWriteSamplerDescriptorsEXT(api_dump, device, samplerCount, pSamplers, pDescriptors);
         }
     }
     VkResult result = device_dispatch_table(device)->WriteSamplerDescriptorsEXT(device, samplerCount, pSamplers, pDescriptors);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWriteSamplerDescriptorsEXT<Format>(ApiDumpInstance::current(), device, samplerCount, pSamplers, pDescriptors);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWriteSamplerDescriptorsEXT(api_dump, device, samplerCount, pSamplers, pDescriptors);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkWriteResourceDescriptorsEXT", "device, resourceCount, pResources, pDescriptors", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkWriteResourceDescriptorsEXT<Format>(ApiDumpInstance::current(), device, resourceCount, pResources, pDescriptors);
+    dump_function_head(api_dump, "vkWriteResourceDescriptorsEXT", "device, resourceCount, pResources, pDescriptors", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkWriteResourceDescriptorsEXT(api_dump, device, resourceCount, pResources, pDescriptors);
         }
     }
     VkResult result = device_dispatch_table(device)->WriteResourceDescriptorsEXT(device, resourceCount, pResources, pDescriptors);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWriteResourceDescriptorsEXT<Format>(ApiDumpInstance::current(), device, resourceCount, pResources, pDescriptors);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWriteResourceDescriptorsEXT(api_dump, device, resourceCount, pResources, pDescriptors);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindSamplerHeapEXT", "commandBuffer, pBindInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindSamplerHeapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pBindInfo);
+    dump_function_head(api_dump, "vkCmdBindSamplerHeapEXT", "commandBuffer, pBindInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindSamplerHeapEXT(api_dump, commandBuffer, pBindInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindSamplerHeapEXT(commandBuffer, pBindInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindSamplerHeapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pBindInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindSamplerHeapEXT(api_dump, commandBuffer, pBindInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindResourceHeapEXT", "commandBuffer, pBindInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindResourceHeapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pBindInfo);
+    dump_function_head(api_dump, "vkCmdBindResourceHeapEXT", "commandBuffer, pBindInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindResourceHeapEXT(api_dump, commandBuffer, pBindInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindResourceHeapEXT(commandBuffer, pBindInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindResourceHeapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pBindInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindResourceHeapEXT(api_dump, commandBuffer, pBindInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPushDataEXT", "commandBuffer, pPushDataInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPushDataEXT<Format>(ApiDumpInstance::current(), commandBuffer, pPushDataInfo);
+    dump_function_head(api_dump, "vkCmdPushDataEXT", "commandBuffer, pPushDataInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPushDataEXT(api_dump, commandBuffer, pPushDataInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPushDataEXT(commandBuffer, pPushDataInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPushDataEXT<Format>(ApiDumpInstance::current(), commandBuffer, pPushDataInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPushDataEXT(api_dump, commandBuffer, pPushDataInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageOpaqueCaptureDataEXT", "device, imageCount, pImages, pDatas", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageOpaqueCaptureDataEXT<Format>(ApiDumpInstance::current(), device, imageCount, pImages, pDatas);
+    dump_function_head(api_dump, "vkGetImageOpaqueCaptureDataEXT", "device, imageCount, pImages, pDatas", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageOpaqueCaptureDataEXT(api_dump, device, imageCount, pImages, pDatas);
         }
     }
     VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT(device, imageCount, pImages, pDatas);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageOpaqueCaptureDataEXT<Format>(ApiDumpInstance::current(), device, imageCount, pImages, pDatas);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageOpaqueCaptureDataEXT(api_dump, device, imageCount, pImages, pDatas);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkRegisterCustomBorderColorEXT", "device, pBorderColor, requestIndex, pIndex", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkRegisterCustomBorderColorEXT<Format>(ApiDumpInstance::current(), device, pBorderColor, requestIndex, pIndex);
+    dump_function_head(api_dump, "vkRegisterCustomBorderColorEXT", "device, pBorderColor, requestIndex, pIndex", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkRegisterCustomBorderColorEXT(api_dump, device, pBorderColor, requestIndex, pIndex);
         }
     }
     VkResult result = device_dispatch_table(device)->RegisterCustomBorderColorEXT(device, pBorderColor, requestIndex, pIndex);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkRegisterCustomBorderColorEXT<Format>(ApiDumpInstance::current(), device, pBorderColor, requestIndex, pIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkRegisterCustomBorderColorEXT(api_dump, device, pBorderColor, requestIndex, pIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUnregisterCustomBorderColorEXT", "device, index", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUnregisterCustomBorderColorEXT<Format>(ApiDumpInstance::current(), device, index);
+    dump_function_head(api_dump, "vkUnregisterCustomBorderColorEXT", "device, index", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUnregisterCustomBorderColorEXT(api_dump, device, index);
         }
     }
     device_dispatch_table(device)->UnregisterCustomBorderColorEXT(device, index);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUnregisterCustomBorderColorEXT<Format>(ApiDumpInstance::current(), device, index);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUnregisterCustomBorderColorEXT(api_dump, device, index);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetTensorOpaqueCaptureDataARM", "device, tensorCount, pTensors, pDatas", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetTensorOpaqueCaptureDataARM<Format>(ApiDumpInstance::current(), device, tensorCount, pTensors, pDatas);
+    dump_function_head(api_dump, "vkGetTensorOpaqueCaptureDataARM", "device, tensorCount, pTensors, pDatas", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetTensorOpaqueCaptureDataARM(api_dump, device, tensorCount, pTensors, pDatas);
         }
     }
     VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM(device, tensorCount, pTensors, pDatas);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetTensorOpaqueCaptureDataARM<Format>(ApiDumpInstance::current(), device, tensorCount, pTensors, pDatas);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetTensorOpaqueCaptureDataARM(api_dump, device, tensorCount, pTensors, pDatas);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetSampleLocationsEXT", "commandBuffer, pSampleLocationsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetSampleLocationsEXT<Format>(ApiDumpInstance::current(), commandBuffer, pSampleLocationsInfo);
+    dump_function_head(api_dump, "vkCmdSetSampleLocationsEXT", "commandBuffer, pSampleLocationsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetSampleLocationsEXT(api_dump, commandBuffer, pSampleLocationsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetSampleLocationsEXT<Format>(ApiDumpInstance::current(), commandBuffer, pSampleLocationsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetSampleLocationsEXT(api_dump, commandBuffer, pSampleLocationsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageDrmFormatModifierPropertiesEXT", "device, image, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageDrmFormatModifierPropertiesEXT<Format>(ApiDumpInstance::current(), device, image, pProperties);
+    dump_function_head(api_dump, "vkGetImageDrmFormatModifierPropertiesEXT", "device, image, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageDrmFormatModifierPropertiesEXT(api_dump, device, image, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageDrmFormatModifierPropertiesEXT<Format>(ApiDumpInstance::current(), device, image, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageDrmFormatModifierPropertiesEXT(api_dump, device, image, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateValidationCacheEXT", "device, pCreateInfo, pAllocator, pValidationCache", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateValidationCacheEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pValidationCache);
+    dump_function_head(api_dump, "vkCreateValidationCacheEXT", "device, pCreateInfo, pAllocator, pValidationCache", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateValidationCacheEXT(api_dump, device, pCreateInfo, pAllocator, pValidationCache);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateValidationCacheEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pValidationCache);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateValidationCacheEXT(api_dump, device, pCreateInfo, pAllocator, pValidationCache);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyValidationCacheEXT", "device, validationCache, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyValidationCacheEXT<Format>(ApiDumpInstance::current(), device, validationCache, pAllocator);
+    dump_function_head(api_dump, "vkDestroyValidationCacheEXT", "device, validationCache, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyValidationCacheEXT(api_dump, device, validationCache, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyValidationCacheEXT(device, validationCache, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyValidationCacheEXT<Format>(ApiDumpInstance::current(), device, validationCache, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyValidationCacheEXT(api_dump, device, validationCache, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkMergeValidationCachesEXT", "device, dstCache, srcCacheCount, pSrcCaches", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkMergeValidationCachesEXT<Format>(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches);
+    dump_function_head(api_dump, "vkMergeValidationCachesEXT", "device, dstCache, srcCacheCount, pSrcCaches", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkMergeValidationCachesEXT(api_dump, device, dstCache, srcCacheCount, pSrcCaches);
         }
     }
     VkResult result = device_dispatch_table(device)->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkMergeValidationCachesEXT<Format>(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkMergeValidationCachesEXT(api_dump, device, dstCache, srcCacheCount, pSrcCaches);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetValidationCacheDataEXT", "device, validationCache, pDataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetValidationCacheDataEXT<Format>(ApiDumpInstance::current(), device, validationCache, pDataSize, pData);
+    dump_function_head(api_dump, "vkGetValidationCacheDataEXT", "device, validationCache, pDataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetValidationCacheDataEXT(api_dump, device, validationCache, pDataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetValidationCacheDataEXT<Format>(ApiDumpInstance::current(), device, validationCache, pDataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetValidationCacheDataEXT(api_dump, device, validationCache, pDataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindShadingRateImageNV", "commandBuffer, imageView, imageLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindShadingRateImageNV<Format>(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout);
+    dump_function_head(api_dump, "vkCmdBindShadingRateImageNV", "commandBuffer, imageView, imageLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindShadingRateImageNV(api_dump, commandBuffer, imageView, imageLayout);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindShadingRateImageNV<Format>(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindShadingRateImageNV(api_dump, commandBuffer, imageView, imageLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportShadingRatePaletteNV", "commandBuffer, firstViewport, viewportCount, pShadingRatePalettes", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewportShadingRatePaletteNV<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
+    dump_function_head(api_dump, "vkCmdSetViewportShadingRatePaletteNV", "commandBuffer, firstViewport, viewportCount, pShadingRatePalettes", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewportShadingRatePaletteNV(api_dump, commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewportShadingRatePaletteNV<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewportShadingRatePaletteNV(api_dump, commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoarseSampleOrderNV", "commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoarseSampleOrderNV<Format>(ApiDumpInstance::current(), commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
+    dump_function_head(api_dump, "vkCmdSetCoarseSampleOrderNV", "commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoarseSampleOrderNV(api_dump, commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoarseSampleOrderNV<Format>(ApiDumpInstance::current(), commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoarseSampleOrderNV(api_dump, commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateAccelerationStructureNV", "device, pCreateInfo, pAllocator, pAccelerationStructure", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateAccelerationStructureNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure);
+    dump_function_head(api_dump, "vkCreateAccelerationStructureNV", "device, pCreateInfo, pAllocator, pAccelerationStructure", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateAccelerationStructureNV(api_dump, device, pCreateInfo, pAllocator, pAccelerationStructure);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateAccelerationStructureNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateAccelerationStructureNV(api_dump, device, pCreateInfo, pAllocator, pAccelerationStructure);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyAccelerationStructureNV", "device, accelerationStructure, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyAccelerationStructureNV<Format>(ApiDumpInstance::current(), device, accelerationStructure, pAllocator);
+    dump_function_head(api_dump, "vkDestroyAccelerationStructureNV", "device, accelerationStructure, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyAccelerationStructureNV(api_dump, device, accelerationStructure, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyAccelerationStructureNV<Format>(ApiDumpInstance::current(), device, accelerationStructure, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyAccelerationStructureNV(api_dump, device, accelerationStructure, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureMemoryRequirementsNV", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetAccelerationStructureMemoryRequirementsNV<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetAccelerationStructureMemoryRequirementsNV", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetAccelerationStructureMemoryRequirementsNV(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetAccelerationStructureMemoryRequirementsNV<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetAccelerationStructureMemoryRequirementsNV(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindAccelerationStructureMemoryNV", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindAccelerationStructureMemoryNV<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindAccelerationStructureMemoryNV", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindAccelerationStructureMemoryNV(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindAccelerationStructureMemoryNV<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindAccelerationStructureMemoryNV(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBuildAccelerationStructureNV", "commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBuildAccelerationStructureNV<Format>(ApiDumpInstance::current(), commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
+    dump_function_head(api_dump, "vkCmdBuildAccelerationStructureNV", "commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBuildAccelerationStructureNV(api_dump, commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBuildAccelerationStructureNV<Format>(ApiDumpInstance::current(), commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBuildAccelerationStructureNV(api_dump, commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyAccelerationStructureNV", "commandBuffer, dst, src, mode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyAccelerationStructureNV<Format>(ApiDumpInstance::current(), commandBuffer, dst, src, mode);
+    dump_function_head(api_dump, "vkCmdCopyAccelerationStructureNV", "commandBuffer, dst, src, mode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyAccelerationStructureNV(api_dump, commandBuffer, dst, src, mode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyAccelerationStructureNV<Format>(ApiDumpInstance::current(), commandBuffer, dst, src, mode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyAccelerationStructureNV(api_dump, commandBuffer, dst, src, mode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(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) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysNV", "commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdTraceRaysNV<Format>(ApiDumpInstance::current(), commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
+    dump_function_head(api_dump, "vkCmdTraceRaysNV", "commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdTraceRaysNV(api_dump, commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
         }
     }
     device_dispatch_table(commandBuffer)->CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdTraceRaysNV<Format>(ApiDumpInstance::current(), commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdTraceRaysNV(api_dump, commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateRayTracingPipelinesNV", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateRayTracingPipelinesNV<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    dump_function_head(api_dump, "vkCreateRayTracingPipelinesNV", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateRayTracingPipelinesNV(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateRayTracingPipelinesNV<Format>(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateRayTracingPipelinesNV(api_dump, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingShaderGroupHandlesKHR", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRayTracingShaderGroupHandlesKHR<Format>(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData);
+    dump_function_head(api_dump, "vkGetRayTracingShaderGroupHandlesKHR", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRayTracingShaderGroupHandlesKHR(api_dump, device, pipeline, firstGroup, groupCount, dataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRayTracingShaderGroupHandlesKHR<Format>(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRayTracingShaderGroupHandlesKHR(api_dump, device, pipeline, firstGroup, groupCount, dataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingShaderGroupHandlesNV", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRayTracingShaderGroupHandlesNV<Format>(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData);
+    dump_function_head(api_dump, "vkGetRayTracingShaderGroupHandlesNV", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRayTracingShaderGroupHandlesNV(api_dump, device, pipeline, firstGroup, groupCount, dataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRayTracingShaderGroupHandlesNV<Format>(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRayTracingShaderGroupHandlesNV(api_dump, device, pipeline, firstGroup, groupCount, dataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureHandleNV", "device, accelerationStructure, dataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetAccelerationStructureHandleNV<Format>(ApiDumpInstance::current(), device, accelerationStructure, dataSize, pData);
+    dump_function_head(api_dump, "vkGetAccelerationStructureHandleNV", "device, accelerationStructure, dataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetAccelerationStructureHandleNV(api_dump, device, accelerationStructure, dataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetAccelerationStructureHandleNV<Format>(ApiDumpInstance::current(), device, accelerationStructure, dataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetAccelerationStructureHandleNV(api_dump, device, accelerationStructure, dataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteAccelerationStructuresPropertiesNV", "commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteAccelerationStructuresPropertiesNV<Format>(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
+    dump_function_head(api_dump, "vkCmdWriteAccelerationStructuresPropertiesNV", "commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(api_dump, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteAccelerationStructuresPropertiesNV<Format>(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(api_dump, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCompileDeferredNV", "device, pipeline, shader", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCompileDeferredNV<Format>(ApiDumpInstance::current(), device, pipeline, shader);
+    dump_function_head(api_dump, "vkCompileDeferredNV", "device, pipeline, shader", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCompileDeferredNV(api_dump, device, pipeline, shader);
         }
     }
     VkResult result = device_dispatch_table(device)->CompileDeferredNV(device, pipeline, shader);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCompileDeferredNV<Format>(ApiDumpInstance::current(), device, pipeline, shader);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCompileDeferredNV(api_dump, device, pipeline, shader);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryHostPointerPropertiesEXT", "device, handleType, pHostPointer, pMemoryHostPointerProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryHostPointerPropertiesEXT<Format>(ApiDumpInstance::current(), device, handleType, pHostPointer, pMemoryHostPointerProperties);
+    dump_function_head(api_dump, "vkGetMemoryHostPointerPropertiesEXT", "device, handleType, pHostPointer, pMemoryHostPointerProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryHostPointerPropertiesEXT(api_dump, device, handleType, pHostPointer, pMemoryHostPointerProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryHostPointerPropertiesEXT<Format>(ApiDumpInstance::current(), device, handleType, pHostPointer, pMemoryHostPointerProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryHostPointerPropertiesEXT(api_dump, device, handleType, pHostPointer, pMemoryHostPointerProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteBufferMarkerAMD", "commandBuffer, pipelineStage, dstBuffer, dstOffset, marker", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteBufferMarkerAMD<Format>(ApiDumpInstance::current(), commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
+    dump_function_head(api_dump, "vkCmdWriteBufferMarkerAMD", "commandBuffer, pipelineStage, dstBuffer, dstOffset, marker", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteBufferMarkerAMD(api_dump, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteBufferMarkerAMD<Format>(ApiDumpInstance::current(), commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteBufferMarkerAMD(api_dump, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteBufferMarker2AMD", "commandBuffer, stage, dstBuffer, dstOffset, marker", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteBufferMarker2AMD<Format>(ApiDumpInstance::current(), commandBuffer, stage, dstBuffer, dstOffset, marker);
+    dump_function_head(api_dump, "vkCmdWriteBufferMarker2AMD", "commandBuffer, stage, dstBuffer, dstOffset, marker", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteBufferMarker2AMD(api_dump, commandBuffer, stage, dstBuffer, dstOffset, marker);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteBufferMarker2AMD<Format>(ApiDumpInstance::current(), commandBuffer, stage, dstBuffer, dstOffset, marker);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteBufferMarker2AMD(api_dump, commandBuffer, stage, dstBuffer, dstOffset, marker);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetCalibratedTimestampsEXT", "device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetCalibratedTimestampsEXT<Format>(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
+    dump_function_head(api_dump, "vkGetCalibratedTimestampsEXT", "device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetCalibratedTimestampsEXT(api_dump, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
         }
     }
     VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetCalibratedTimestampsEXT<Format>(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetCalibratedTimestampsEXT(api_dump, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksNV", "commandBuffer, taskCount, firstTask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMeshTasksNV<Format>(ApiDumpInstance::current(), commandBuffer, taskCount, firstTask);
+    dump_function_head(api_dump, "vkCmdDrawMeshTasksNV", "commandBuffer, taskCount, firstTask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMeshTasksNV(api_dump, commandBuffer, taskCount, firstTask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMeshTasksNV<Format>(ApiDumpInstance::current(), commandBuffer, taskCount, firstTask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMeshTasksNV(api_dump, commandBuffer, taskCount, firstTask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectNV", "commandBuffer, buffer, offset, drawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMeshTasksIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawMeshTasksIndirectNV", "commandBuffer, buffer, offset, drawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMeshTasksIndirectNV(api_dump, commandBuffer, buffer, offset, drawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMeshTasksIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMeshTasksIndirectNV(api_dump, commandBuffer, buffer, offset, drawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectCountNV", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMeshTasksIndirectCountNV<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawMeshTasksIndirectCountNV", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMeshTasksIndirectCountNV(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMeshTasksIndirectCountNV<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMeshTasksIndirectCountNV(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetExclusiveScissorEnableNV", "commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetExclusiveScissorEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
+    dump_function_head(api_dump, "vkCmdSetExclusiveScissorEnableNV", "commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetExclusiveScissorEnableNV(api_dump, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetExclusiveScissorEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetExclusiveScissorEnableNV(api_dump, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetExclusiveScissorNV", "commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetExclusiveScissorNV<Format>(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
+    dump_function_head(api_dump, "vkCmdSetExclusiveScissorNV", "commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetExclusiveScissorNV(api_dump, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetExclusiveScissorNV<Format>(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetExclusiveScissorNV(api_dump, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCheckpointNV", "commandBuffer, pCheckpointMarker", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCheckpointNV<Format>(ApiDumpInstance::current(), commandBuffer, pCheckpointMarker);
+    dump_function_head(api_dump, "vkCmdSetCheckpointNV", "commandBuffer, pCheckpointMarker", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCheckpointNV(api_dump, commandBuffer, pCheckpointMarker);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCheckpointNV<Format>(ApiDumpInstance::current(), commandBuffer, pCheckpointMarker);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCheckpointNV(api_dump, commandBuffer, pCheckpointMarker);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetQueueCheckpointDataNV", "queue, pCheckpointDataCount, pCheckpointData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetQueueCheckpointDataNV<Format>(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData);
+    dump_function_head(api_dump, "vkGetQueueCheckpointDataNV", "queue, pCheckpointDataCount, pCheckpointData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetQueueCheckpointDataNV(api_dump, queue, pCheckpointDataCount, pCheckpointData);
         }
     }
     device_dispatch_table(queue)->GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetQueueCheckpointDataNV<Format>(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetQueueCheckpointDataNV(api_dump, queue, pCheckpointDataCount, pCheckpointData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetQueueCheckpointData2NV", "queue, pCheckpointDataCount, pCheckpointData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetQueueCheckpointData2NV<Format>(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData);
+    dump_function_head(api_dump, "vkGetQueueCheckpointData2NV", "queue, pCheckpointDataCount, pCheckpointData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetQueueCheckpointData2NV(api_dump, queue, pCheckpointDataCount, pCheckpointData);
         }
     }
     device_dispatch_table(queue)->GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetQueueCheckpointData2NV<Format>(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetQueueCheckpointData2NV(api_dump, queue, pCheckpointDataCount, pCheckpointData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetSwapchainPresentTimingQueueSizeEXT", "device, swapchain, size", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetSwapchainPresentTimingQueueSizeEXT<Format>(ApiDumpInstance::current(), device, swapchain, size);
+    dump_function_head(api_dump, "vkSetSwapchainPresentTimingQueueSizeEXT", "device, swapchain, size", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(api_dump, device, swapchain, size);
         }
     }
     VkResult result = device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetSwapchainPresentTimingQueueSizeEXT<Format>(ApiDumpInstance::current(), device, swapchain, size);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(api_dump, device, swapchain, size);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainTimingPropertiesEXT", "device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSwapchainTimingPropertiesEXT<Format>(ApiDumpInstance::current(), device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter);
+    dump_function_head(api_dump, "vkGetSwapchainTimingPropertiesEXT", "device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSwapchainTimingPropertiesEXT(api_dump, device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSwapchainTimingPropertiesEXT<Format>(ApiDumpInstance::current(), device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSwapchainTimingPropertiesEXT(api_dump, device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainTimeDomainPropertiesEXT", "device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSwapchainTimeDomainPropertiesEXT<Format>(ApiDumpInstance::current(), device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter);
+    dump_function_head(api_dump, "vkGetSwapchainTimeDomainPropertiesEXT", "device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSwapchainTimeDomainPropertiesEXT(api_dump, device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSwapchainTimeDomainPropertiesEXT<Format>(ApiDumpInstance::current(), device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSwapchainTimeDomainPropertiesEXT(api_dump, device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPastPresentationTimingEXT", "device, pPastPresentationTimingInfo, pPastPresentationTimingProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPastPresentationTimingEXT<Format>(ApiDumpInstance::current(), device, pPastPresentationTimingInfo, pPastPresentationTimingProperties);
+    dump_function_head(api_dump, "vkGetPastPresentationTimingEXT", "device, pPastPresentationTimingInfo, pPastPresentationTimingProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPastPresentationTimingEXT(api_dump, device, pPastPresentationTimingInfo, pPastPresentationTimingProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPastPresentationTimingEXT(device, pPastPresentationTimingInfo, pPastPresentationTimingProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPastPresentationTimingEXT<Format>(ApiDumpInstance::current(), device, pPastPresentationTimingInfo, pPastPresentationTimingProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPastPresentationTimingEXT(api_dump, device, pPastPresentationTimingInfo, pPastPresentationTimingProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkInitializePerformanceApiINTEL", "device, pInitializeInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkInitializePerformanceApiINTEL<Format>(ApiDumpInstance::current(), device, pInitializeInfo);
+    dump_function_head(api_dump, "vkInitializePerformanceApiINTEL", "device, pInitializeInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkInitializePerformanceApiINTEL(api_dump, device, pInitializeInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->InitializePerformanceApiINTEL(device, pInitializeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkInitializePerformanceApiINTEL<Format>(ApiDumpInstance::current(), device, pInitializeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkInitializePerformanceApiINTEL(api_dump, device, pInitializeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUninitializePerformanceApiINTEL", "device", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUninitializePerformanceApiINTEL<Format>(ApiDumpInstance::current(), device);
+    dump_function_head(api_dump, "vkUninitializePerformanceApiINTEL", "device", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUninitializePerformanceApiINTEL(api_dump, device);
         }
     }
     device_dispatch_table(device)->UninitializePerformanceApiINTEL(device);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUninitializePerformanceApiINTEL<Format>(ApiDumpInstance::current(), device);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUninitializePerformanceApiINTEL(api_dump, device);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPerformanceMarkerINTEL", "commandBuffer, pMarkerInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPerformanceMarkerINTEL<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
+    dump_function_head(api_dump, "vkCmdSetPerformanceMarkerINTEL", "commandBuffer, pMarkerInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPerformanceMarkerINTEL(api_dump, commandBuffer, pMarkerInfo);
         }
     }
     VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPerformanceMarkerINTEL<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPerformanceMarkerINTEL(api_dump, commandBuffer, pMarkerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPerformanceStreamMarkerINTEL", "commandBuffer, pMarkerInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPerformanceStreamMarkerINTEL<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
+    dump_function_head(api_dump, "vkCmdSetPerformanceStreamMarkerINTEL", "commandBuffer, pMarkerInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPerformanceStreamMarkerINTEL(api_dump, commandBuffer, pMarkerInfo);
         }
     }
     VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPerformanceStreamMarkerINTEL<Format>(ApiDumpInstance::current(), commandBuffer, pMarkerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPerformanceStreamMarkerINTEL(api_dump, commandBuffer, pMarkerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPerformanceOverrideINTEL", "commandBuffer, pOverrideInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPerformanceOverrideINTEL<Format>(ApiDumpInstance::current(), commandBuffer, pOverrideInfo);
+    dump_function_head(api_dump, "vkCmdSetPerformanceOverrideINTEL", "commandBuffer, pOverrideInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPerformanceOverrideINTEL(api_dump, commandBuffer, pOverrideInfo);
         }
     }
     VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPerformanceOverrideINTEL<Format>(ApiDumpInstance::current(), commandBuffer, pOverrideInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPerformanceOverrideINTEL(api_dump, commandBuffer, pOverrideInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAcquirePerformanceConfigurationINTEL", "device, pAcquireInfo, pConfiguration", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquirePerformanceConfigurationINTEL<Format>(ApiDumpInstance::current(), device, pAcquireInfo, pConfiguration);
+    dump_function_head(api_dump, "vkAcquirePerformanceConfigurationINTEL", "device, pAcquireInfo, pConfiguration", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquirePerformanceConfigurationINTEL(api_dump, device, pAcquireInfo, pConfiguration);
         }
     }
     VkResult result = device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquirePerformanceConfigurationINTEL<Format>(ApiDumpInstance::current(), device, pAcquireInfo, pConfiguration);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquirePerformanceConfigurationINTEL(api_dump, device, pAcquireInfo, pConfiguration);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkReleasePerformanceConfigurationINTEL", "device, configuration", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleasePerformanceConfigurationINTEL<Format>(ApiDumpInstance::current(), device, configuration);
+    dump_function_head(api_dump, "vkReleasePerformanceConfigurationINTEL", "device, configuration", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleasePerformanceConfigurationINTEL(api_dump, device, configuration);
         }
     }
     VkResult result = device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL(device, configuration);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleasePerformanceConfigurationINTEL<Format>(ApiDumpInstance::current(), device, configuration);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleasePerformanceConfigurationINTEL(api_dump, device, configuration);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueSetPerformanceConfigurationINTEL", "queue, configuration", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueSetPerformanceConfigurationINTEL<Format>(ApiDumpInstance::current(), queue, configuration);
+    dump_function_head(api_dump, "vkQueueSetPerformanceConfigurationINTEL", "queue, configuration", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueSetPerformanceConfigurationINTEL(api_dump, queue, configuration);
         }
     }
     VkResult result = device_dispatch_table(queue)->QueueSetPerformanceConfigurationINTEL(queue, configuration);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueSetPerformanceConfigurationINTEL<Format>(ApiDumpInstance::current(), queue, configuration);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueSetPerformanceConfigurationINTEL(api_dump, queue, configuration);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPerformanceParameterINTEL", "device, parameter, pValue", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPerformanceParameterINTEL<Format>(ApiDumpInstance::current(), device, parameter, pValue);
+    dump_function_head(api_dump, "vkGetPerformanceParameterINTEL", "device, parameter, pValue", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPerformanceParameterINTEL(api_dump, device, parameter, pValue);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPerformanceParameterINTEL(device, parameter, pValue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPerformanceParameterINTEL<Format>(ApiDumpInstance::current(), device, parameter, pValue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPerformanceParameterINTEL(api_dump, device, parameter, pValue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetLocalDimmingAMD", "device, swapChain, localDimmingEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetLocalDimmingAMD<Format>(ApiDumpInstance::current(), device, swapChain, localDimmingEnable);
+    dump_function_head(api_dump, "vkSetLocalDimmingAMD", "device, swapChain, localDimmingEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetLocalDimmingAMD(api_dump, device, swapChain, localDimmingEnable);
         }
     }
     device_dispatch_table(device)->SetLocalDimmingAMD(device, swapChain, localDimmingEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetLocalDimmingAMD<Format>(ApiDumpInstance::current(), device, swapChain, localDimmingEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetLocalDimmingAMD(api_dump, device, swapChain, localDimmingEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferDeviceAddressEXT", "device, pInfo", "VkDeviceAddress");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferDeviceAddressEXT<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetBufferDeviceAddressEXT", "device, pInfo", "VkDeviceAddress");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferDeviceAddressEXT(api_dump, device, pInfo);
         }
     }
     VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressEXT(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferDeviceAddressEXT<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceAddress", result, dump_return_value_VkDeviceAddress);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferDeviceAddressEXT(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAcquireFullScreenExclusiveModeEXT", "device, swapchain", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAcquireFullScreenExclusiveModeEXT<Format>(ApiDumpInstance::current(), device, swapchain);
+    dump_function_head(api_dump, "vkAcquireFullScreenExclusiveModeEXT", "device, swapchain", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAcquireFullScreenExclusiveModeEXT(api_dump, device, swapchain);
         }
     }
     VkResult result = device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT(device, swapchain);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAcquireFullScreenExclusiveModeEXT<Format>(ApiDumpInstance::current(), device, swapchain);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAcquireFullScreenExclusiveModeEXT(api_dump, device, swapchain);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkReleaseFullScreenExclusiveModeEXT", "device, swapchain", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleaseFullScreenExclusiveModeEXT<Format>(ApiDumpInstance::current(), device, swapchain);
+    dump_function_head(api_dump, "vkReleaseFullScreenExclusiveModeEXT", "device, swapchain", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleaseFullScreenExclusiveModeEXT(api_dump, device, swapchain);
         }
     }
     VkResult result = device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT(device, swapchain);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleaseFullScreenExclusiveModeEXT<Format>(ApiDumpInstance::current(), device, swapchain);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleaseFullScreenExclusiveModeEXT(api_dump, device, swapchain);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupSurfacePresentModes2EXT", "device, pSurfaceInfo, pModes", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceGroupSurfacePresentModes2EXT<Format>(ApiDumpInstance::current(), device, pSurfaceInfo, pModes);
+    dump_function_head(api_dump, "vkGetDeviceGroupSurfacePresentModes2EXT", "device, pSurfaceInfo, pModes", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(api_dump, device, pSurfaceInfo, pModes);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceGroupSurfacePresentModes2EXT<Format>(ApiDumpInstance::current(), device, pSurfaceInfo, pModes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(api_dump, device, pSurfaceInfo, pModes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStippleEXT", "commandBuffer, lineStippleFactor, lineStipplePattern", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLineStippleEXT<Format>(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern);
+    dump_function_head(api_dump, "vkCmdSetLineStippleEXT", "commandBuffer, lineStippleFactor, lineStipplePattern", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLineStippleEXT(api_dump, commandBuffer, lineStippleFactor, lineStipplePattern);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLineStippleEXT<Format>(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLineStippleEXT(api_dump, commandBuffer, lineStippleFactor, lineStipplePattern);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkResetQueryPoolEXT", "device, queryPool, firstQuery, queryCount", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkResetQueryPoolEXT<Format>(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount);
+    dump_function_head(api_dump, "vkResetQueryPoolEXT", "device, queryPool, firstQuery, queryCount", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkResetQueryPoolEXT(api_dump, device, queryPool, firstQuery, queryCount);
         }
     }
     device_dispatch_table(device)->ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkResetQueryPoolEXT<Format>(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkResetQueryPoolEXT(api_dump, device, queryPool, firstQuery, queryCount);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCullModeEXT", "commandBuffer, cullMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCullModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, cullMode);
+    dump_function_head(api_dump, "vkCmdSetCullModeEXT", "commandBuffer, cullMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCullModeEXT(api_dump, commandBuffer, cullMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCullModeEXT(commandBuffer, cullMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCullModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, cullMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCullModeEXT(api_dump, commandBuffer, cullMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetFrontFaceEXT", "commandBuffer, frontFace", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetFrontFaceEXT<Format>(ApiDumpInstance::current(), commandBuffer, frontFace);
+    dump_function_head(api_dump, "vkCmdSetFrontFaceEXT", "commandBuffer, frontFace", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetFrontFaceEXT(api_dump, commandBuffer, frontFace);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetFrontFaceEXT(commandBuffer, frontFace);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetFrontFaceEXT<Format>(ApiDumpInstance::current(), commandBuffer, frontFace);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetFrontFaceEXT(api_dump, commandBuffer, frontFace);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveTopologyEXT", "commandBuffer, primitiveTopology", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPrimitiveTopologyEXT<Format>(ApiDumpInstance::current(), commandBuffer, primitiveTopology);
+    dump_function_head(api_dump, "vkCmdSetPrimitiveTopologyEXT", "commandBuffer, primitiveTopology", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPrimitiveTopologyEXT(api_dump, commandBuffer, primitiveTopology);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPrimitiveTopologyEXT<Format>(ApiDumpInstance::current(), commandBuffer, primitiveTopology);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPrimitiveTopologyEXT(api_dump, commandBuffer, primitiveTopology);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWithCountEXT", "commandBuffer, viewportCount, pViewports", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewportWithCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports);
+    dump_function_head(api_dump, "vkCmdSetViewportWithCountEXT", "commandBuffer, viewportCount, pViewports", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewportWithCountEXT(api_dump, commandBuffer, viewportCount, pViewports);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewportWithCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewportWithCountEXT(api_dump, commandBuffer, viewportCount, pViewports);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetScissorWithCountEXT", "commandBuffer, scissorCount, pScissors", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetScissorWithCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors);
+    dump_function_head(api_dump, "vkCmdSetScissorWithCountEXT", "commandBuffer, scissorCount, pScissors", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetScissorWithCountEXT(api_dump, commandBuffer, scissorCount, pScissors);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetScissorWithCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetScissorWithCountEXT(api_dump, commandBuffer, scissorCount, pScissors);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindVertexBuffers2EXT", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindVertexBuffers2EXT<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+    dump_function_head(api_dump, "vkCmdBindVertexBuffers2EXT", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindVertexBuffers2EXT(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindVertexBuffers2EXT<Format>(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindVertexBuffers2EXT(api_dump, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthTestEnableEXT", "commandBuffer, depthTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthTestEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthTestEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthTestEnableEXT", "commandBuffer, depthTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthTestEnableEXT(api_dump, commandBuffer, depthTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthTestEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthTestEnableEXT(api_dump, commandBuffer, depthTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthWriteEnableEXT", "commandBuffer, depthWriteEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthWriteEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthWriteEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthWriteEnableEXT", "commandBuffer, depthWriteEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthWriteEnableEXT(api_dump, commandBuffer, depthWriteEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthWriteEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthWriteEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthWriteEnableEXT(api_dump, commandBuffer, depthWriteEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthCompareOpEXT", "commandBuffer, depthCompareOp", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthCompareOpEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthCompareOp);
+    dump_function_head(api_dump, "vkCmdSetDepthCompareOpEXT", "commandBuffer, depthCompareOp", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthCompareOpEXT(api_dump, commandBuffer, depthCompareOp);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthCompareOpEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthCompareOp);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthCompareOpEXT(api_dump, commandBuffer, depthCompareOp);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBoundsTestEnableEXT", "commandBuffer, depthBoundsTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBoundsTestEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthBoundsTestEnableEXT", "commandBuffer, depthBoundsTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBoundsTestEnableEXT(api_dump, commandBuffer, depthBoundsTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBoundsTestEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBoundsTestEnableEXT(api_dump, commandBuffer, depthBoundsTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilTestEnableEXT", "commandBuffer, stencilTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilTestEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, stencilTestEnable);
+    dump_function_head(api_dump, "vkCmdSetStencilTestEnableEXT", "commandBuffer, stencilTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilTestEnableEXT(api_dump, commandBuffer, stencilTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilTestEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, stencilTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilTestEnableEXT(api_dump, commandBuffer, stencilTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilOpEXT", "commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetStencilOpEXT<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
+    dump_function_head(api_dump, "vkCmdSetStencilOpEXT", "commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetStencilOpEXT(api_dump, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetStencilOpEXT<Format>(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetStencilOpEXT(api_dump, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToImageEXT", "device, pCopyMemoryToImageInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyMemoryToImageEXT<Format>(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo);
+    dump_function_head(api_dump, "vkCopyMemoryToImageEXT", "device, pCopyMemoryToImageInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyMemoryToImageEXT(api_dump, device, pCopyMemoryToImageInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyMemoryToImageEXT(device, pCopyMemoryToImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyMemoryToImageEXT<Format>(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyMemoryToImageEXT(api_dump, device, pCopyMemoryToImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyImageToMemoryEXT", "device, pCopyImageToMemoryInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyImageToMemoryEXT<Format>(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo);
+    dump_function_head(api_dump, "vkCopyImageToMemoryEXT", "device, pCopyImageToMemoryInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyImageToMemoryEXT(api_dump, device, pCopyImageToMemoryInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyImageToMemoryEXT(device, pCopyImageToMemoryInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyImageToMemoryEXT<Format>(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyImageToMemoryEXT(api_dump, device, pCopyImageToMemoryInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyImageToImageEXT", "device, pCopyImageToImageInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyImageToImageEXT<Format>(ApiDumpInstance::current(), device, pCopyImageToImageInfo);
+    dump_function_head(api_dump, "vkCopyImageToImageEXT", "device, pCopyImageToImageInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyImageToImageEXT(api_dump, device, pCopyImageToImageInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyImageToImageEXT(device, pCopyImageToImageInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyImageToImageEXT<Format>(ApiDumpInstance::current(), device, pCopyImageToImageInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyImageToImageEXT(api_dump, device, pCopyImageToImageInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkTransitionImageLayoutEXT", "device, transitionCount, pTransitions", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkTransitionImageLayoutEXT<Format>(ApiDumpInstance::current(), device, transitionCount, pTransitions);
+    dump_function_head(api_dump, "vkTransitionImageLayoutEXT", "device, transitionCount, pTransitions", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkTransitionImageLayoutEXT(api_dump, device, transitionCount, pTransitions);
         }
     }
     VkResult result = device_dispatch_table(device)->TransitionImageLayoutEXT(device, transitionCount, pTransitions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkTransitionImageLayoutEXT<Format>(ApiDumpInstance::current(), device, transitionCount, pTransitions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkTransitionImageLayoutEXT(api_dump, device, transitionCount, pTransitions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout2EXT", "device, image, pSubresource, pLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageSubresourceLayout2EXT<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
+    dump_function_head(api_dump, "vkGetImageSubresourceLayout2EXT", "device, image, pSubresource, pLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageSubresourceLayout2EXT(api_dump, device, image, pSubresource, pLayout);
         }
     }
     device_dispatch_table(device)->GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageSubresourceLayout2EXT<Format>(ApiDumpInstance::current(), device, image, pSubresource, pLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageSubresourceLayout2EXT(api_dump, device, image, pSubresource, pLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkReleaseSwapchainImagesEXT", "device, pReleaseInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkReleaseSwapchainImagesEXT<Format>(ApiDumpInstance::current(), device, pReleaseInfo);
+    dump_function_head(api_dump, "vkReleaseSwapchainImagesEXT", "device, pReleaseInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkReleaseSwapchainImagesEXT(api_dump, device, pReleaseInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesEXT(device, pReleaseInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkReleaseSwapchainImagesEXT<Format>(ApiDumpInstance::current(), device, pReleaseInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkReleaseSwapchainImagesEXT(api_dump, device, pReleaseInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetGeneratedCommandsMemoryRequirementsNV", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetGeneratedCommandsMemoryRequirementsNV<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetGeneratedCommandsMemoryRequirementsNV", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetGeneratedCommandsMemoryRequirementsNV<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPreprocessGeneratedCommandsNV", "commandBuffer, pGeneratedCommandsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPreprocessGeneratedCommandsNV<Format>(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo);
+    dump_function_head(api_dump, "vkCmdPreprocessGeneratedCommandsNV", "commandBuffer, pGeneratedCommandsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPreprocessGeneratedCommandsNV(api_dump, commandBuffer, pGeneratedCommandsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPreprocessGeneratedCommandsNV<Format>(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPreprocessGeneratedCommandsNV(api_dump, commandBuffer, pGeneratedCommandsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdExecuteGeneratedCommandsNV", "commandBuffer, isPreprocessed, pGeneratedCommandsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdExecuteGeneratedCommandsNV<Format>(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
+    dump_function_head(api_dump, "vkCmdExecuteGeneratedCommandsNV", "commandBuffer, isPreprocessed, pGeneratedCommandsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdExecuteGeneratedCommandsNV(api_dump, commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdExecuteGeneratedCommandsNV<Format>(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdExecuteGeneratedCommandsNV(api_dump, commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindPipelineShaderGroupNV", "commandBuffer, pipelineBindPoint, pipeline, groupIndex", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindPipelineShaderGroupNV<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline, groupIndex);
+    dump_function_head(api_dump, "vkCmdBindPipelineShaderGroupNV", "commandBuffer, pipelineBindPoint, pipeline, groupIndex", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindPipelineShaderGroupNV(api_dump, commandBuffer, pipelineBindPoint, pipeline, groupIndex);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindPipelineShaderGroupNV<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline, groupIndex);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindPipelineShaderGroupNV(api_dump, commandBuffer, pipelineBindPoint, pipeline, groupIndex);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateIndirectCommandsLayoutNV", "device, pCreateInfo, pAllocator, pIndirectCommandsLayout", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateIndirectCommandsLayoutNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+    dump_function_head(api_dump, "vkCreateIndirectCommandsLayoutNV", "device, pCreateInfo, pAllocator, pIndirectCommandsLayout", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateIndirectCommandsLayoutNV(api_dump, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateIndirectCommandsLayoutNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateIndirectCommandsLayoutNV(api_dump, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyIndirectCommandsLayoutNV", "device, indirectCommandsLayout, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyIndirectCommandsLayoutNV<Format>(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator);
+    dump_function_head(api_dump, "vkDestroyIndirectCommandsLayoutNV", "device, indirectCommandsLayout, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyIndirectCommandsLayoutNV(api_dump, device, indirectCommandsLayout, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyIndirectCommandsLayoutNV<Format>(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyIndirectCommandsLayoutNV(api_dump, device, indirectCommandsLayout, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBias2EXT", "commandBuffer, pDepthBiasInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBias2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pDepthBiasInfo);
+    dump_function_head(api_dump, "vkCmdSetDepthBias2EXT", "commandBuffer, pDepthBiasInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBias2EXT(api_dump, commandBuffer, pDepthBiasInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBias2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pDepthBiasInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBias2EXT(api_dump, commandBuffer, pDepthBiasInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreatePrivateDataSlotEXT", "device, pCreateInfo, pAllocator, pPrivateDataSlot", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreatePrivateDataSlotEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot);
+    dump_function_head(api_dump, "vkCreatePrivateDataSlotEXT", "device, pCreateInfo, pAllocator, pPrivateDataSlot", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreatePrivateDataSlotEXT(api_dump, device, pCreateInfo, pAllocator, pPrivateDataSlot);
         }
     }
     VkResult result = device_dispatch_table(device)->CreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreatePrivateDataSlotEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreatePrivateDataSlotEXT(api_dump, device, pCreateInfo, pAllocator, pPrivateDataSlot);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyPrivateDataSlotEXT", "device, privateDataSlot, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyPrivateDataSlotEXT<Format>(ApiDumpInstance::current(), device, privateDataSlot, pAllocator);
+    dump_function_head(api_dump, "vkDestroyPrivateDataSlotEXT", "device, privateDataSlot, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyPrivateDataSlotEXT(api_dump, device, privateDataSlot, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyPrivateDataSlotEXT<Format>(ApiDumpInstance::current(), device, privateDataSlot, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyPrivateDataSlotEXT(api_dump, device, privateDataSlot, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetPrivateDataEXT", "device, objectType, objectHandle, privateDataSlot, data", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetPrivateDataEXT<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data);
+    dump_function_head(api_dump, "vkSetPrivateDataEXT", "device, objectType, objectHandle, privateDataSlot, data", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetPrivateDataEXT(api_dump, device, objectType, objectHandle, privateDataSlot, data);
         }
     }
     VkResult result = device_dispatch_table(device)->SetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetPrivateDataEXT<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetPrivateDataEXT(api_dump, device, objectType, objectHandle, privateDataSlot, data);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPrivateDataEXT", "device, objectType, objectHandle, privateDataSlot, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPrivateDataEXT<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData);
+    dump_function_head(api_dump, "vkGetPrivateDataEXT", "device, objectType, objectHandle, privateDataSlot, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPrivateDataEXT(api_dump, device, objectType, objectHandle, privateDataSlot, pData);
         }
     }
     device_dispatch_table(device)->GetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPrivateDataEXT<Format>(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPrivateDataEXT(api_dump, device, objectType, objectHandle, privateDataSlot, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateCudaModuleNV", "device, pCreateInfo, pAllocator, pModule", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateCudaModuleNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule);
+    dump_function_head(api_dump, "vkCreateCudaModuleNV", "device, pCreateInfo, pAllocator, pModule", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateCudaModuleNV(api_dump, device, pCreateInfo, pAllocator, pModule);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateCudaModuleNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateCudaModuleNV(api_dump, device, pCreateInfo, pAllocator, pModule);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetCudaModuleCacheNV", "device, module, pCacheSize, pCacheData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetCudaModuleCacheNV<Format>(ApiDumpInstance::current(), device, module, pCacheSize, pCacheData);
+    dump_function_head(api_dump, "vkGetCudaModuleCacheNV", "device, module, pCacheSize, pCacheData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetCudaModuleCacheNV(api_dump, device, module, pCacheSize, pCacheData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetCudaModuleCacheNV<Format>(ApiDumpInstance::current(), device, module, pCacheSize, pCacheData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetCudaModuleCacheNV(api_dump, device, module, pCacheSize, pCacheData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateCudaFunctionNV", "device, pCreateInfo, pAllocator, pFunction", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateCudaFunctionNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction);
+    dump_function_head(api_dump, "vkCreateCudaFunctionNV", "device, pCreateInfo, pAllocator, pFunction", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateCudaFunctionNV(api_dump, device, pCreateInfo, pAllocator, pFunction);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateCudaFunctionNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateCudaFunctionNV(api_dump, device, pCreateInfo, pAllocator, pFunction);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyCudaModuleNV", "device, module, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyCudaModuleNV<Format>(ApiDumpInstance::current(), device, module, pAllocator);
+    dump_function_head(api_dump, "vkDestroyCudaModuleNV", "device, module, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyCudaModuleNV(api_dump, device, module, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyCudaModuleNV(device, module, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyCudaModuleNV<Format>(ApiDumpInstance::current(), device, module, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyCudaModuleNV(api_dump, device, module, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyCudaFunctionNV", "device, function, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyCudaFunctionNV<Format>(ApiDumpInstance::current(), device, function, pAllocator);
+    dump_function_head(api_dump, "vkDestroyCudaFunctionNV", "device, function, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyCudaFunctionNV(api_dump, device, function, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyCudaFunctionNV(device, function, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyCudaFunctionNV<Format>(ApiDumpInstance::current(), device, function, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyCudaFunctionNV(api_dump, device, function, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCudaLaunchKernelNV", "commandBuffer, pLaunchInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCudaLaunchKernelNV<Format>(ApiDumpInstance::current(), commandBuffer, pLaunchInfo);
+    dump_function_head(api_dump, "vkCmdCudaLaunchKernelNV", "commandBuffer, pLaunchInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCudaLaunchKernelNV(api_dump, commandBuffer, pLaunchInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCudaLaunchKernelNV<Format>(ApiDumpInstance::current(), commandBuffer, pLaunchInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCudaLaunchKernelNV(api_dump, commandBuffer, pLaunchInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchTileQCOM", "commandBuffer, pDispatchTileInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchTileQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pDispatchTileInfo);
+    dump_function_head(api_dump, "vkCmdDispatchTileQCOM", "commandBuffer, pDispatchTileInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchTileQCOM(api_dump, commandBuffer, pDispatchTileInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchTileQCOM(commandBuffer, pDispatchTileInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchTileQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pDispatchTileInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchTileQCOM(api_dump, commandBuffer, pDispatchTileInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginPerTileExecutionQCOM", "commandBuffer, pPerTileBeginInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginPerTileExecutionQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pPerTileBeginInfo);
+    dump_function_head(api_dump, "vkCmdBeginPerTileExecutionQCOM", "commandBuffer, pPerTileBeginInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginPerTileExecutionQCOM(api_dump, commandBuffer, pPerTileBeginInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginPerTileExecutionQCOM(commandBuffer, pPerTileBeginInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginPerTileExecutionQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pPerTileBeginInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginPerTileExecutionQCOM(api_dump, commandBuffer, pPerTileBeginInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndPerTileExecutionQCOM", "commandBuffer, pPerTileEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndPerTileExecutionQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pPerTileEndInfo);
+    dump_function_head(api_dump, "vkCmdEndPerTileExecutionQCOM", "commandBuffer, pPerTileEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndPerTileExecutionQCOM(api_dump, commandBuffer, pPerTileEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndPerTileExecutionQCOM(commandBuffer, pPerTileEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndPerTileExecutionQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pPerTileEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndPerTileExecutionQCOM(api_dump, commandBuffer, pPerTileEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_METAL_EXT)
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkExportMetalObjectsEXT", "device, pMetalObjectsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkExportMetalObjectsEXT<Format>(ApiDumpInstance::current(), device, pMetalObjectsInfo);
+    dump_function_head(api_dump, "vkExportMetalObjectsEXT", "device, pMetalObjectsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkExportMetalObjectsEXT(api_dump, device, pMetalObjectsInfo);
         }
     }
     device_dispatch_table(device)->ExportMetalObjectsEXT(device, pMetalObjectsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkExportMetalObjectsEXT<Format>(ApiDumpInstance::current(), device, pMetalObjectsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkExportMetalObjectsEXT(api_dump, device, pMetalObjectsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #endif  // VK_USE_PLATFORM_METAL_EXT
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutSizeEXT", "device, layout, pLayoutSizeInBytes", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorSetLayoutSizeEXT<Format>(ApiDumpInstance::current(), device, layout, pLayoutSizeInBytes);
+    dump_function_head(api_dump, "vkGetDescriptorSetLayoutSizeEXT", "device, layout, pLayoutSizeInBytes", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorSetLayoutSizeEXT(api_dump, device, layout, pLayoutSizeInBytes);
         }
     }
     device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorSetLayoutSizeEXT<Format>(ApiDumpInstance::current(), device, layout, pLayoutSizeInBytes);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorSetLayoutSizeEXT(api_dump, device, layout, pLayoutSizeInBytes);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutBindingOffsetEXT", "device, layout, binding, pOffset", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT<Format>(ApiDumpInstance::current(), device, layout, binding, pOffset);
+    dump_function_head(api_dump, "vkGetDescriptorSetLayoutBindingOffsetEXT", "device, layout, binding, pOffset", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(api_dump, device, layout, binding, pOffset);
         }
     }
     device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT<Format>(ApiDumpInstance::current(), device, layout, binding, pOffset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(api_dump, device, layout, binding, pOffset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorEXT", "device, pDescriptorInfo, dataSize, pDescriptor", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorEXT<Format>(ApiDumpInstance::current(), device, pDescriptorInfo, dataSize, pDescriptor);
+    dump_function_head(api_dump, "vkGetDescriptorEXT", "device, pDescriptorInfo, dataSize, pDescriptor", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorEXT(api_dump, device, pDescriptorInfo, dataSize, pDescriptor);
         }
     }
     device_dispatch_table(device)->GetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorEXT<Format>(ApiDumpInstance::current(), device, pDescriptorInfo, dataSize, pDescriptor);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorEXT(api_dump, device, pDescriptorInfo, dataSize, pDescriptor);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorBuffersEXT", "commandBuffer, bufferCount, pBindingInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindDescriptorBuffersEXT<Format>(ApiDumpInstance::current(), commandBuffer, bufferCount, pBindingInfos);
+    dump_function_head(api_dump, "vkCmdBindDescriptorBuffersEXT", "commandBuffer, bufferCount, pBindingInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindDescriptorBuffersEXT(api_dump, commandBuffer, bufferCount, pBindingInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindDescriptorBuffersEXT<Format>(ApiDumpInstance::current(), commandBuffer, bufferCount, pBindingInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindDescriptorBuffersEXT(api_dump, commandBuffer, bufferCount, pBindingInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDescriptorBufferOffsetsEXT", "commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDescriptorBufferOffsetsEXT<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets);
+    dump_function_head(api_dump, "vkCmdSetDescriptorBufferOffsetsEXT", "commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDescriptorBufferOffsetsEXT(api_dump, commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDescriptorBufferOffsetsEXT<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDescriptorBufferOffsetsEXT(api_dump, commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorBufferEmbeddedSamplersEXT", "commandBuffer, pipelineBindPoint, layout, set", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set);
+    dump_function_head(api_dump, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT", "commandBuffer, pipelineBindPoint, layout, set", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(api_dump, commandBuffer, pipelineBindPoint, layout, set);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(api_dump, commandBuffer, pipelineBindPoint, layout, set);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetBufferOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetImageOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetImageViewOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetImageViewOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSamplerOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetSamplerOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetFragmentShadingRateEnumNV", "commandBuffer, shadingRate, combinerOps", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetFragmentShadingRateEnumNV<Format>(ApiDumpInstance::current(), commandBuffer, shadingRate, combinerOps);
+    dump_function_head(api_dump, "vkCmdSetFragmentShadingRateEnumNV", "commandBuffer, shadingRate, combinerOps", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetFragmentShadingRateEnumNV(api_dump, commandBuffer, shadingRate, combinerOps);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetFragmentShadingRateEnumNV<Format>(ApiDumpInstance::current(), commandBuffer, shadingRate, combinerOps);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetFragmentShadingRateEnumNV(api_dump, commandBuffer, shadingRate, combinerOps);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceFaultInfoEXT", "device, pFaultCounts, pFaultInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceFaultInfoEXT<Format>(ApiDumpInstance::current(), device, pFaultCounts, pFaultInfo);
+    dump_function_head(api_dump, "vkGetDeviceFaultInfoEXT", "device, pFaultCounts, pFaultInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceFaultInfoEXT(api_dump, device, pFaultCounts, pFaultInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceFaultInfoEXT<Format>(ApiDumpInstance::current(), device, pFaultCounts, pFaultInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceFaultInfoEXT(api_dump, device, pFaultCounts, pFaultInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetVertexInputEXT", "commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetVertexInputEXT<Format>(ApiDumpInstance::current(), commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
+    dump_function_head(api_dump, "vkCmdSetVertexInputEXT", "commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetVertexInputEXT(api_dump, commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetVertexInputEXT<Format>(ApiDumpInstance::current(), commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetVertexInputEXT(api_dump, commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_FUCHSIA)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryZirconHandleFUCHSIA", "device, pGetZirconHandleInfo, pZirconHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryZirconHandleFUCHSIA<Format>(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle);
+    dump_function_head(api_dump, "vkGetMemoryZirconHandleFUCHSIA", "device, pGetZirconHandleInfo, pZirconHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryZirconHandleFUCHSIA(api_dump, device, pGetZirconHandleInfo, pZirconHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryZirconHandleFUCHSIA<Format>(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryZirconHandleFUCHSIA(api_dump, device, pGetZirconHandleInfo, pZirconHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryZirconHandlePropertiesFUCHSIA", "device, handleType, zirconHandle, pMemoryZirconHandleProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA<Format>(ApiDumpInstance::current(), device, handleType, zirconHandle, pMemoryZirconHandleProperties);
+    dump_function_head(api_dump, "vkGetMemoryZirconHandlePropertiesFUCHSIA", "device, handleType, zirconHandle, pMemoryZirconHandleProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(api_dump, device, handleType, zirconHandle, pMemoryZirconHandleProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA<Format>(ApiDumpInstance::current(), device, handleType, zirconHandle, pMemoryZirconHandleProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(api_dump, device, handleType, zirconHandle, pMemoryZirconHandleProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkImportSemaphoreZirconHandleFUCHSIA", "device, pImportSemaphoreZirconHandleInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkImportSemaphoreZirconHandleFUCHSIA<Format>(ApiDumpInstance::current(), device, pImportSemaphoreZirconHandleInfo);
+    dump_function_head(api_dump, "vkImportSemaphoreZirconHandleFUCHSIA", "device, pImportSemaphoreZirconHandleInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkImportSemaphoreZirconHandleFUCHSIA(api_dump, device, pImportSemaphoreZirconHandleInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkImportSemaphoreZirconHandleFUCHSIA<Format>(ApiDumpInstance::current(), device, pImportSemaphoreZirconHandleInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkImportSemaphoreZirconHandleFUCHSIA(api_dump, device, pImportSemaphoreZirconHandleInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreZirconHandleFUCHSIA", "device, pGetZirconHandleInfo, pZirconHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetSemaphoreZirconHandleFUCHSIA<Format>(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle);
+    dump_function_head(api_dump, "vkGetSemaphoreZirconHandleFUCHSIA", "device, pGetZirconHandleInfo, pZirconHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetSemaphoreZirconHandleFUCHSIA(api_dump, device, pGetZirconHandleInfo, pZirconHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetSemaphoreZirconHandleFUCHSIA<Format>(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetSemaphoreZirconHandleFUCHSIA(api_dump, device, pGetZirconHandleInfo, pZirconHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateBufferCollectionFUCHSIA", "device, pCreateInfo, pAllocator, pCollection", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateBufferCollectionFUCHSIA<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCollection);
+    dump_function_head(api_dump, "vkCreateBufferCollectionFUCHSIA", "device, pCreateInfo, pAllocator, pCollection", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateBufferCollectionFUCHSIA(api_dump, device, pCreateInfo, pAllocator, pCollection);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateBufferCollectionFUCHSIA<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCollection);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateBufferCollectionFUCHSIA(api_dump, device, pCreateInfo, pAllocator, pCollection);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetBufferCollectionImageConstraintsFUCHSIA", "device, collection, pImageConstraintsInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pImageConstraintsInfo);
+    dump_function_head(api_dump, "vkSetBufferCollectionImageConstraintsFUCHSIA", "device, collection, pImageConstraintsInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(api_dump, device, collection, pImageConstraintsInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pImageConstraintsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(api_dump, device, collection, pImageConstraintsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetBufferCollectionBufferConstraintsFUCHSIA", "device, collection, pBufferConstraintsInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pBufferConstraintsInfo);
+    dump_function_head(api_dump, "vkSetBufferCollectionBufferConstraintsFUCHSIA", "device, collection, pBufferConstraintsInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(api_dump, device, collection, pBufferConstraintsInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pBufferConstraintsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(api_dump, device, collection, pBufferConstraintsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyBufferCollectionFUCHSIA", "device, collection, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyBufferCollectionFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pAllocator);
+    dump_function_head(api_dump, "vkDestroyBufferCollectionFUCHSIA", "device, collection, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyBufferCollectionFUCHSIA(api_dump, device, collection, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyBufferCollectionFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyBufferCollectionFUCHSIA(api_dump, device, collection, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetBufferCollectionPropertiesFUCHSIA", "device, collection, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetBufferCollectionPropertiesFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pProperties);
+    dump_function_head(api_dump, "vkGetBufferCollectionPropertiesFUCHSIA", "device, collection, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetBufferCollectionPropertiesFUCHSIA(api_dump, device, collection, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetBufferCollectionPropertiesFUCHSIA<Format>(ApiDumpInstance::current(), device, collection, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetBufferCollectionPropertiesFUCHSIA(api_dump, device, collection, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_FUCHSIA
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", "device, renderpass, pMaxWorkgroupSize", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI<Format>(ApiDumpInstance::current(), device, renderpass, pMaxWorkgroupSize);
+    dump_function_head(api_dump, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", "device, renderpass, pMaxWorkgroupSize", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(api_dump, device, renderpass, pMaxWorkgroupSize);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI<Format>(ApiDumpInstance::current(), device, renderpass, pMaxWorkgroupSize);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(api_dump, device, renderpass, pMaxWorkgroupSize);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSubpassShadingHUAWEI", "commandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSubpassShadingHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer);
+    dump_function_head(api_dump, "vkCmdSubpassShadingHUAWEI", "commandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSubpassShadingHUAWEI(api_dump, commandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSubpassShadingHUAWEI(commandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSubpassShadingHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSubpassShadingHUAWEI(api_dump, commandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindInvocationMaskHUAWEI", "commandBuffer, imageView, imageLayout", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindInvocationMaskHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout);
+    dump_function_head(api_dump, "vkCmdBindInvocationMaskHUAWEI", "commandBuffer, imageView, imageLayout", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindInvocationMaskHUAWEI(api_dump, commandBuffer, imageView, imageLayout);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindInvocationMaskHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindInvocationMaskHUAWEI(api_dump, commandBuffer, imageView, imageLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryRemoteAddressNV", "device, pMemoryGetRemoteAddressInfo, pAddress", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryRemoteAddressNV<Format>(ApiDumpInstance::current(), device, pMemoryGetRemoteAddressInfo, pAddress);
+    dump_function_head(api_dump, "vkGetMemoryRemoteAddressNV", "device, pMemoryGetRemoteAddressInfo, pAddress", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryRemoteAddressNV(api_dump, device, pMemoryGetRemoteAddressInfo, pAddress);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryRemoteAddressNV<Format>(ApiDumpInstance::current(), device, pMemoryGetRemoteAddressInfo, pAddress);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryRemoteAddressNV(api_dump, device, pMemoryGetRemoteAddressInfo, pAddress);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelinePropertiesEXT", "device, pPipelineInfo, pPipelineProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelinePropertiesEXT<Format>(ApiDumpInstance::current(), device, pPipelineInfo, pPipelineProperties);
+    dump_function_head(api_dump, "vkGetPipelinePropertiesEXT", "device, pPipelineInfo, pPipelineProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelinePropertiesEXT(api_dump, device, pPipelineInfo, pPipelineProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelinePropertiesEXT<Format>(ApiDumpInstance::current(), device, pPipelineInfo, pPipelineProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelinePropertiesEXT(api_dump, device, pPipelineInfo, pPipelineProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPatchControlPointsEXT", "commandBuffer, patchControlPoints", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPatchControlPointsEXT<Format>(ApiDumpInstance::current(), commandBuffer, patchControlPoints);
+    dump_function_head(api_dump, "vkCmdSetPatchControlPointsEXT", "commandBuffer, patchControlPoints", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPatchControlPointsEXT(api_dump, commandBuffer, patchControlPoints);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPatchControlPointsEXT<Format>(ApiDumpInstance::current(), commandBuffer, patchControlPoints);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPatchControlPointsEXT(api_dump, commandBuffer, patchControlPoints);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizerDiscardEnableEXT", "commandBuffer, rasterizerDiscardEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRasterizerDiscardEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable);
+    dump_function_head(api_dump, "vkCmdSetRasterizerDiscardEnableEXT", "commandBuffer, rasterizerDiscardEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRasterizerDiscardEnableEXT(api_dump, commandBuffer, rasterizerDiscardEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRasterizerDiscardEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRasterizerDiscardEnableEXT(api_dump, commandBuffer, rasterizerDiscardEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBiasEnableEXT", "commandBuffer, depthBiasEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthBiasEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthBiasEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthBiasEnableEXT", "commandBuffer, depthBiasEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthBiasEnableEXT(api_dump, commandBuffer, depthBiasEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthBiasEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthBiasEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthBiasEnableEXT(api_dump, commandBuffer, depthBiasEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLogicOpEXT", "commandBuffer, logicOp", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLogicOpEXT<Format>(ApiDumpInstance::current(), commandBuffer, logicOp);
+    dump_function_head(api_dump, "vkCmdSetLogicOpEXT", "commandBuffer, logicOp", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLogicOpEXT(api_dump, commandBuffer, logicOp);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLogicOpEXT(commandBuffer, logicOp);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLogicOpEXT<Format>(ApiDumpInstance::current(), commandBuffer, logicOp);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLogicOpEXT(api_dump, commandBuffer, logicOp);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveRestartEnableEXT", "commandBuffer, primitiveRestartEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPrimitiveRestartEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable);
+    dump_function_head(api_dump, "vkCmdSetPrimitiveRestartEnableEXT", "commandBuffer, primitiveRestartEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPrimitiveRestartEnableEXT(api_dump, commandBuffer, primitiveRestartEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPrimitiveRestartEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPrimitiveRestartEnableEXT(api_dump, commandBuffer, primitiveRestartEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorWriteEnableEXT", "commandBuffer, attachmentCount, pColorWriteEnables", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetColorWriteEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, attachmentCount, pColorWriteEnables);
+    dump_function_head(api_dump, "vkCmdSetColorWriteEnableEXT", "commandBuffer, attachmentCount, pColorWriteEnables", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetColorWriteEnableEXT(api_dump, commandBuffer, attachmentCount, pColorWriteEnables);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetColorWriteEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, attachmentCount, pColorWriteEnables);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetColorWriteEnableEXT(api_dump, commandBuffer, attachmentCount, pColorWriteEnables);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMultiEXT", "commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMultiEXT<Format>(ApiDumpInstance::current(), commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
+    dump_function_head(api_dump, "vkCmdDrawMultiEXT", "commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMultiEXT(api_dump, commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMultiEXT<Format>(ApiDumpInstance::current(), commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMultiEXT(api_dump, commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMultiIndexedEXT", "commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMultiIndexedEXT<Format>(ApiDumpInstance::current(), commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
+    dump_function_head(api_dump, "vkCmdDrawMultiIndexedEXT", "commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMultiIndexedEXT(api_dump, commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMultiIndexedEXT<Format>(ApiDumpInstance::current(), commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMultiIndexedEXT(api_dump, commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateMicromapEXT", "device, pCreateInfo, pAllocator, pMicromap", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateMicromapEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pMicromap);
+    dump_function_head(api_dump, "vkCreateMicromapEXT", "device, pCreateInfo, pAllocator, pMicromap", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateMicromapEXT(api_dump, device, pCreateInfo, pAllocator, pMicromap);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateMicromapEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pMicromap);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateMicromapEXT(api_dump, device, pCreateInfo, pAllocator, pMicromap);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyMicromapEXT", "device, micromap, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyMicromapEXT<Format>(ApiDumpInstance::current(), device, micromap, pAllocator);
+    dump_function_head(api_dump, "vkDestroyMicromapEXT", "device, micromap, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyMicromapEXT(api_dump, device, micromap, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyMicromapEXT(device, micromap, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyMicromapEXT<Format>(ApiDumpInstance::current(), device, micromap, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyMicromapEXT(api_dump, device, micromap, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBuildMicromapsEXT", "commandBuffer, infoCount, pInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBuildMicromapsEXT<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos);
+    dump_function_head(api_dump, "vkCmdBuildMicromapsEXT", "commandBuffer, infoCount, pInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBuildMicromapsEXT(api_dump, commandBuffer, infoCount, pInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBuildMicromapsEXT<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBuildMicromapsEXT(api_dump, commandBuffer, infoCount, pInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBuildMicromapsEXT", "device, deferredOperation, infoCount, pInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBuildMicromapsEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos);
+    dump_function_head(api_dump, "vkBuildMicromapsEXT", "device, deferredOperation, infoCount, pInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBuildMicromapsEXT(api_dump, device, deferredOperation, infoCount, pInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BuildMicromapsEXT(device, deferredOperation, infoCount, pInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBuildMicromapsEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBuildMicromapsEXT(api_dump, device, deferredOperation, infoCount, pInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyMicromapEXT", "device, deferredOperation, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyMicromapEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
+    dump_function_head(api_dump, "vkCopyMicromapEXT", "device, deferredOperation, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyMicromapEXT(api_dump, device, deferredOperation, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyMicromapEXT(device, deferredOperation, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyMicromapEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyMicromapEXT(api_dump, device, deferredOperation, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyMicromapToMemoryEXT", "device, deferredOperation, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyMicromapToMemoryEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
+    dump_function_head(api_dump, "vkCopyMicromapToMemoryEXT", "device, deferredOperation, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyMicromapToMemoryEXT(api_dump, device, deferredOperation, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyMicromapToMemoryEXT(device, deferredOperation, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyMicromapToMemoryEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyMicromapToMemoryEXT(api_dump, device, deferredOperation, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToMicromapEXT", "device, deferredOperation, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyMemoryToMicromapEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
+    dump_function_head(api_dump, "vkCopyMemoryToMicromapEXT", "device, deferredOperation, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyMemoryToMicromapEXT(api_dump, device, deferredOperation, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyMemoryToMicromapEXT(device, deferredOperation, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyMemoryToMicromapEXT<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyMemoryToMicromapEXT(api_dump, device, deferredOperation, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkWriteMicromapsPropertiesEXT", "device, micromapCount, pMicromaps, queryType, dataSize, pData, stride", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkWriteMicromapsPropertiesEXT<Format>(ApiDumpInstance::current(), device, micromapCount, pMicromaps, queryType, dataSize, pData, stride);
+    dump_function_head(api_dump, "vkWriteMicromapsPropertiesEXT", "device, micromapCount, pMicromaps, queryType, dataSize, pData, stride", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkWriteMicromapsPropertiesEXT(api_dump, device, micromapCount, pMicromaps, queryType, dataSize, pData, stride);
         }
     }
     VkResult result = device_dispatch_table(device)->WriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWriteMicromapsPropertiesEXT<Format>(ApiDumpInstance::current(), device, micromapCount, pMicromaps, queryType, dataSize, pData, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWriteMicromapsPropertiesEXT(api_dump, device, micromapCount, pMicromaps, queryType, dataSize, pData, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMicromapEXT", "commandBuffer, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMicromapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
+    dump_function_head(api_dump, "vkCmdCopyMicromapEXT", "commandBuffer, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMicromapEXT(api_dump, commandBuffer, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMicromapEXT(commandBuffer, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMicromapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMicromapEXT(api_dump, commandBuffer, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMicromapToMemoryEXT", "commandBuffer, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMicromapToMemoryEXT<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
+    dump_function_head(api_dump, "vkCmdCopyMicromapToMemoryEXT", "commandBuffer, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMicromapToMemoryEXT(api_dump, commandBuffer, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMicromapToMemoryEXT(commandBuffer, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMicromapToMemoryEXT<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMicromapToMemoryEXT(api_dump, commandBuffer, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToMicromapEXT", "commandBuffer, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMemoryToMicromapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
+    dump_function_head(api_dump, "vkCmdCopyMemoryToMicromapEXT", "commandBuffer, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMemoryToMicromapEXT(api_dump, commandBuffer, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMemoryToMicromapEXT(commandBuffer, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMemoryToMicromapEXT<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMemoryToMicromapEXT(api_dump, commandBuffer, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteMicromapsPropertiesEXT", "commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteMicromapsPropertiesEXT<Format>(ApiDumpInstance::current(), commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery);
+    dump_function_head(api_dump, "vkCmdWriteMicromapsPropertiesEXT", "commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteMicromapsPropertiesEXT(api_dump, commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteMicromapsPropertiesEXT<Format>(ApiDumpInstance::current(), commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteMicromapsPropertiesEXT(api_dump, commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMicromapCompatibilityEXT", "device, pVersionInfo, pCompatibility", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceMicromapCompatibilityEXT<Format>(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility);
+    dump_function_head(api_dump, "vkGetDeviceMicromapCompatibilityEXT", "device, pVersionInfo, pCompatibility", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceMicromapCompatibilityEXT(api_dump, device, pVersionInfo, pCompatibility);
         }
     }
     device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceMicromapCompatibilityEXT<Format>(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceMicromapCompatibilityEXT(api_dump, device, pVersionInfo, pCompatibility);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMicromapBuildSizesEXT", "device, buildType, pBuildInfo, pSizeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMicromapBuildSizesEXT<Format>(ApiDumpInstance::current(), device, buildType, pBuildInfo, pSizeInfo);
+    dump_function_head(api_dump, "vkGetMicromapBuildSizesEXT", "device, buildType, pBuildInfo, pSizeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMicromapBuildSizesEXT(api_dump, device, buildType, pBuildInfo, pSizeInfo);
         }
     }
     device_dispatch_table(device)->GetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMicromapBuildSizesEXT<Format>(ApiDumpInstance::current(), device, buildType, pBuildInfo, pSizeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMicromapBuildSizesEXT(api_dump, device, buildType, pBuildInfo, pSizeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawClusterHUAWEI", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawClusterHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ);
+    dump_function_head(api_dump, "vkCmdDrawClusterHUAWEI", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawClusterHUAWEI(api_dump, commandBuffer, groupCountX, groupCountY, groupCountZ);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawClusterHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawClusterHUAWEI(api_dump, commandBuffer, groupCountX, groupCountY, groupCountZ);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawClusterIndirectHUAWEI", "commandBuffer, buffer, offset", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawClusterIndirectHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset);
+    dump_function_head(api_dump, "vkCmdDrawClusterIndirectHUAWEI", "commandBuffer, buffer, offset", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawClusterIndirectHUAWEI(api_dump, commandBuffer, buffer, offset);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawClusterIndirectHUAWEI<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawClusterIndirectHUAWEI(api_dump, commandBuffer, buffer, offset);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetDeviceMemoryPriorityEXT", "device, memory, priority", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetDeviceMemoryPriorityEXT<Format>(ApiDumpInstance::current(), device, memory, priority);
+    dump_function_head(api_dump, "vkSetDeviceMemoryPriorityEXT", "device, memory, priority", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetDeviceMemoryPriorityEXT(api_dump, device, memory, priority);
         }
     }
     device_dispatch_table(device)->SetDeviceMemoryPriorityEXT(device, memory, priority);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetDeviceMemoryPriorityEXT<Format>(ApiDumpInstance::current(), device, memory, priority);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetDeviceMemoryPriorityEXT(api_dump, device, memory, priority);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutHostMappingInfoVALVE", "device, pBindingReference, pHostMapping", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE<Format>(ApiDumpInstance::current(), device, pBindingReference, pHostMapping);
+    dump_function_head(api_dump, "vkGetDescriptorSetLayoutHostMappingInfoVALVE", "device, pBindingReference, pHostMapping", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(api_dump, device, pBindingReference, pHostMapping);
         }
     }
     device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE<Format>(ApiDumpInstance::current(), device, pBindingReference, pHostMapping);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(api_dump, device, pBindingReference, pHostMapping);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetHostMappingVALVE", "device, descriptorSet, ppData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDescriptorSetHostMappingVALVE<Format>(ApiDumpInstance::current(), device, descriptorSet, ppData);
+    dump_function_head(api_dump, "vkGetDescriptorSetHostMappingVALVE", "device, descriptorSet, ppData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDescriptorSetHostMappingVALVE(api_dump, device, descriptorSet, ppData);
         }
     }
     device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDescriptorSetHostMappingVALVE<Format>(ApiDumpInstance::current(), device, descriptorSet, ppData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDescriptorSetHostMappingVALVE(api_dump, device, descriptorSet, ppData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryIndirectNV", "commandBuffer, copyBufferAddress, copyCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMemoryIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride);
+    dump_function_head(api_dump, "vkCmdCopyMemoryIndirectNV", "commandBuffer, copyBufferAddress, copyCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMemoryIndirectNV(api_dump, commandBuffer, copyBufferAddress, copyCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMemoryIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMemoryIndirectNV(api_dump, commandBuffer, copyBufferAddress, copyCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToImageIndirectNV", "commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMemoryToImageIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources);
+    dump_function_head(api_dump, "vkCmdCopyMemoryToImageIndirectNV", "commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMemoryToImageIndirectNV(api_dump, commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMemoryToImageIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMemoryToImageIndirectNV(api_dump, commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryNV", "commandBuffer, decompressRegionCount, pDecompressMemoryRegions", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDecompressMemoryNV<Format>(ApiDumpInstance::current(), commandBuffer, decompressRegionCount, pDecompressMemoryRegions);
+    dump_function_head(api_dump, "vkCmdDecompressMemoryNV", "commandBuffer, decompressRegionCount, pDecompressMemoryRegions", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDecompressMemoryNV(api_dump, commandBuffer, decompressRegionCount, pDecompressMemoryRegions);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDecompressMemoryNV<Format>(ApiDumpInstance::current(), commandBuffer, decompressRegionCount, pDecompressMemoryRegions);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDecompressMemoryNV(api_dump, commandBuffer, decompressRegionCount, pDecompressMemoryRegions);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryIndirectCountNV", "commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDecompressMemoryIndirectCountNV<Format>(ApiDumpInstance::current(), commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride);
+    dump_function_head(api_dump, "vkCmdDecompressMemoryIndirectCountNV", "commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDecompressMemoryIndirectCountNV(api_dump, commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDecompressMemoryIndirectCountNV<Format>(ApiDumpInstance::current(), commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDecompressMemoryIndirectCountNV(api_dump, commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineIndirectMemoryRequirementsNV", "device, pCreateInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineIndirectMemoryRequirementsNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetPipelineIndirectMemoryRequirementsNV", "device, pCreateInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineIndirectMemoryRequirementsNV(api_dump, device, pCreateInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineIndirectMemoryRequirementsNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineIndirectMemoryRequirementsNV(api_dump, device, pCreateInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdUpdatePipelineIndirectBufferNV", "commandBuffer, pipelineBindPoint, pipeline", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdUpdatePipelineIndirectBufferNV<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline);
+    dump_function_head(api_dump, "vkCmdUpdatePipelineIndirectBufferNV", "commandBuffer, pipelineBindPoint, pipeline", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdUpdatePipelineIndirectBufferNV(api_dump, commandBuffer, pipelineBindPoint, pipeline);
         }
     }
     device_dispatch_table(commandBuffer)->CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdUpdatePipelineIndirectBufferNV<Format>(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdUpdatePipelineIndirectBufferNV(api_dump, commandBuffer, pipelineBindPoint, pipeline);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPipelineIndirectDeviceAddressNV", "device, pInfo", "VkDeviceAddress");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPipelineIndirectDeviceAddressNV<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetPipelineIndirectDeviceAddressNV", "device, pInfo", "VkDeviceAddress");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPipelineIndirectDeviceAddressNV(api_dump, device, pInfo);
         }
     }
     VkDeviceAddress result = device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPipelineIndirectDeviceAddressNV<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceAddress", result, dump_return_value_VkDeviceAddress);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPipelineIndirectDeviceAddressNV(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #if defined(VK_USE_PLATFORM_OHOS)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetNativeBufferPropertiesOHOS", "device, buffer, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetNativeBufferPropertiesOHOS<Format>(ApiDumpInstance::current(), device, buffer, pProperties);
+    dump_function_head(api_dump, "vkGetNativeBufferPropertiesOHOS", "device, buffer, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetNativeBufferPropertiesOHOS(api_dump, device, buffer, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetNativeBufferPropertiesOHOS(device, buffer, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetNativeBufferPropertiesOHOS<Format>(ApiDumpInstance::current(), device, buffer, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetNativeBufferPropertiesOHOS(api_dump, device, buffer, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryNativeBufferOHOS", "device, pInfo, pBuffer", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryNativeBufferOHOS<Format>(ApiDumpInstance::current(), device, pInfo, pBuffer);
+    dump_function_head(api_dump, "vkGetMemoryNativeBufferOHOS", "device, pInfo, pBuffer", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryNativeBufferOHOS(api_dump, device, pInfo, pBuffer);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryNativeBufferOHOS(device, pInfo, pBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryNativeBufferOHOS<Format>(ApiDumpInstance::current(), device, pInfo, pBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryNativeBufferOHOS(api_dump, device, pInfo, pBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_OHOS
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClampEnableEXT", "commandBuffer, depthClampEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthClampEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthClampEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthClampEnableEXT", "commandBuffer, depthClampEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthClampEnableEXT(api_dump, commandBuffer, depthClampEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthClampEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthClampEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthClampEnableEXT(api_dump, commandBuffer, depthClampEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetPolygonModeEXT", "commandBuffer, polygonMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetPolygonModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, polygonMode);
+    dump_function_head(api_dump, "vkCmdSetPolygonModeEXT", "commandBuffer, polygonMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetPolygonModeEXT(api_dump, commandBuffer, polygonMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetPolygonModeEXT(commandBuffer, polygonMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetPolygonModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, polygonMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetPolygonModeEXT(api_dump, commandBuffer, polygonMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizationSamplesEXT", "commandBuffer, rasterizationSamples", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRasterizationSamplesEXT<Format>(ApiDumpInstance::current(), commandBuffer, rasterizationSamples);
+    dump_function_head(api_dump, "vkCmdSetRasterizationSamplesEXT", "commandBuffer, rasterizationSamples", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRasterizationSamplesEXT(api_dump, commandBuffer, rasterizationSamples);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRasterizationSamplesEXT<Format>(ApiDumpInstance::current(), commandBuffer, rasterizationSamples);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRasterizationSamplesEXT(api_dump, commandBuffer, rasterizationSamples);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetSampleMaskEXT", "commandBuffer, samples, pSampleMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetSampleMaskEXT<Format>(ApiDumpInstance::current(), commandBuffer, samples, pSampleMask);
+    dump_function_head(api_dump, "vkCmdSetSampleMaskEXT", "commandBuffer, samples, pSampleMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetSampleMaskEXT(api_dump, commandBuffer, samples, pSampleMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetSampleMaskEXT<Format>(ApiDumpInstance::current(), commandBuffer, samples, pSampleMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetSampleMaskEXT(api_dump, commandBuffer, samples, pSampleMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetAlphaToCoverageEnableEXT", "commandBuffer, alphaToCoverageEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetAlphaToCoverageEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, alphaToCoverageEnable);
+    dump_function_head(api_dump, "vkCmdSetAlphaToCoverageEnableEXT", "commandBuffer, alphaToCoverageEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetAlphaToCoverageEnableEXT(api_dump, commandBuffer, alphaToCoverageEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetAlphaToCoverageEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, alphaToCoverageEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetAlphaToCoverageEnableEXT(api_dump, commandBuffer, alphaToCoverageEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetAlphaToOneEnableEXT", "commandBuffer, alphaToOneEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetAlphaToOneEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, alphaToOneEnable);
+    dump_function_head(api_dump, "vkCmdSetAlphaToOneEnableEXT", "commandBuffer, alphaToOneEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetAlphaToOneEnableEXT(api_dump, commandBuffer, alphaToOneEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetAlphaToOneEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, alphaToOneEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetAlphaToOneEnableEXT(api_dump, commandBuffer, alphaToOneEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLogicOpEnableEXT", "commandBuffer, logicOpEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLogicOpEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, logicOpEnable);
+    dump_function_head(api_dump, "vkCmdSetLogicOpEnableEXT", "commandBuffer, logicOpEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLogicOpEnableEXT(api_dump, commandBuffer, logicOpEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLogicOpEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, logicOpEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLogicOpEnableEXT(api_dump, commandBuffer, logicOpEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorBlendEnableEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetColorBlendEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables);
+    dump_function_head(api_dump, "vkCmdSetColorBlendEnableEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetColorBlendEnableEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetColorBlendEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetColorBlendEnableEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorBlendEquationEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetColorBlendEquationEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations);
+    dump_function_head(api_dump, "vkCmdSetColorBlendEquationEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetColorBlendEquationEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetColorBlendEquationEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetColorBlendEquationEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorWriteMaskEXT", "commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetColorWriteMaskEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks);
+    dump_function_head(api_dump, "vkCmdSetColorWriteMaskEXT", "commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetColorWriteMaskEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetColorWriteMaskEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetColorWriteMaskEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetTessellationDomainOriginEXT", "commandBuffer, domainOrigin", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetTessellationDomainOriginEXT<Format>(ApiDumpInstance::current(), commandBuffer, domainOrigin);
+    dump_function_head(api_dump, "vkCmdSetTessellationDomainOriginEXT", "commandBuffer, domainOrigin", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetTessellationDomainOriginEXT(api_dump, commandBuffer, domainOrigin);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetTessellationDomainOriginEXT<Format>(ApiDumpInstance::current(), commandBuffer, domainOrigin);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetTessellationDomainOriginEXT(api_dump, commandBuffer, domainOrigin);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizationStreamEXT", "commandBuffer, rasterizationStream", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRasterizationStreamEXT<Format>(ApiDumpInstance::current(), commandBuffer, rasterizationStream);
+    dump_function_head(api_dump, "vkCmdSetRasterizationStreamEXT", "commandBuffer, rasterizationStream", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRasterizationStreamEXT(api_dump, commandBuffer, rasterizationStream);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRasterizationStreamEXT<Format>(ApiDumpInstance::current(), commandBuffer, rasterizationStream);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRasterizationStreamEXT(api_dump, commandBuffer, rasterizationStream);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetConservativeRasterizationModeEXT", "commandBuffer, conservativeRasterizationMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetConservativeRasterizationModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, conservativeRasterizationMode);
+    dump_function_head(api_dump, "vkCmdSetConservativeRasterizationModeEXT", "commandBuffer, conservativeRasterizationMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetConservativeRasterizationModeEXT(api_dump, commandBuffer, conservativeRasterizationMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetConservativeRasterizationModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, conservativeRasterizationMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetConservativeRasterizationModeEXT(api_dump, commandBuffer, conservativeRasterizationMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetExtraPrimitiveOverestimationSizeEXT", "commandBuffer, extraPrimitiveOverestimationSize", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT<Format>(ApiDumpInstance::current(), commandBuffer, extraPrimitiveOverestimationSize);
+    dump_function_head(api_dump, "vkCmdSetExtraPrimitiveOverestimationSizeEXT", "commandBuffer, extraPrimitiveOverestimationSize", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(api_dump, commandBuffer, extraPrimitiveOverestimationSize);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT<Format>(ApiDumpInstance::current(), commandBuffer, extraPrimitiveOverestimationSize);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(api_dump, commandBuffer, extraPrimitiveOverestimationSize);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClipEnableEXT", "commandBuffer, depthClipEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthClipEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthClipEnable);
+    dump_function_head(api_dump, "vkCmdSetDepthClipEnableEXT", "commandBuffer, depthClipEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthClipEnableEXT(api_dump, commandBuffer, depthClipEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthClipEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthClipEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthClipEnableEXT(api_dump, commandBuffer, depthClipEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetSampleLocationsEnableEXT", "commandBuffer, sampleLocationsEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetSampleLocationsEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, sampleLocationsEnable);
+    dump_function_head(api_dump, "vkCmdSetSampleLocationsEnableEXT", "commandBuffer, sampleLocationsEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetSampleLocationsEnableEXT(api_dump, commandBuffer, sampleLocationsEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetSampleLocationsEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, sampleLocationsEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetSampleLocationsEnableEXT(api_dump, commandBuffer, sampleLocationsEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorBlendAdvancedEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetColorBlendAdvancedEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced);
+    dump_function_head(api_dump, "vkCmdSetColorBlendAdvancedEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetColorBlendAdvancedEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetColorBlendAdvancedEXT<Format>(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetColorBlendAdvancedEXT(api_dump, commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetProvokingVertexModeEXT", "commandBuffer, provokingVertexMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetProvokingVertexModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, provokingVertexMode);
+    dump_function_head(api_dump, "vkCmdSetProvokingVertexModeEXT", "commandBuffer, provokingVertexMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetProvokingVertexModeEXT(api_dump, commandBuffer, provokingVertexMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetProvokingVertexModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, provokingVertexMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetProvokingVertexModeEXT(api_dump, commandBuffer, provokingVertexMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineRasterizationModeEXT", "commandBuffer, lineRasterizationMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLineRasterizationModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, lineRasterizationMode);
+    dump_function_head(api_dump, "vkCmdSetLineRasterizationModeEXT", "commandBuffer, lineRasterizationMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLineRasterizationModeEXT(api_dump, commandBuffer, lineRasterizationMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLineRasterizationModeEXT<Format>(ApiDumpInstance::current(), commandBuffer, lineRasterizationMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLineRasterizationModeEXT(api_dump, commandBuffer, lineRasterizationMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStippleEnableEXT", "commandBuffer, stippledLineEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetLineStippleEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, stippledLineEnable);
+    dump_function_head(api_dump, "vkCmdSetLineStippleEnableEXT", "commandBuffer, stippledLineEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetLineStippleEnableEXT(api_dump, commandBuffer, stippledLineEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetLineStippleEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, stippledLineEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetLineStippleEnableEXT(api_dump, commandBuffer, stippledLineEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClipNegativeOneToOneEXT", "commandBuffer, negativeOneToOne", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthClipNegativeOneToOneEXT<Format>(ApiDumpInstance::current(), commandBuffer, negativeOneToOne);
+    dump_function_head(api_dump, "vkCmdSetDepthClipNegativeOneToOneEXT", "commandBuffer, negativeOneToOne", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(api_dump, commandBuffer, negativeOneToOne);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthClipNegativeOneToOneEXT<Format>(ApiDumpInstance::current(), commandBuffer, negativeOneToOne);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(api_dump, commandBuffer, negativeOneToOne);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWScalingEnableNV", "commandBuffer, viewportWScalingEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewportWScalingEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, viewportWScalingEnable);
+    dump_function_head(api_dump, "vkCmdSetViewportWScalingEnableNV", "commandBuffer, viewportWScalingEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewportWScalingEnableNV(api_dump, commandBuffer, viewportWScalingEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewportWScalingEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, viewportWScalingEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewportWScalingEnableNV(api_dump, commandBuffer, viewportWScalingEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportSwizzleNV", "commandBuffer, firstViewport, viewportCount, pViewportSwizzles", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetViewportSwizzleNV<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportSwizzles);
+    dump_function_head(api_dump, "vkCmdSetViewportSwizzleNV", "commandBuffer, firstViewport, viewportCount, pViewportSwizzles", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetViewportSwizzleNV(api_dump, commandBuffer, firstViewport, viewportCount, pViewportSwizzles);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetViewportSwizzleNV<Format>(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportSwizzles);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetViewportSwizzleNV(api_dump, commandBuffer, firstViewport, viewportCount, pViewportSwizzles);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageToColorEnableNV", "commandBuffer, coverageToColorEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoverageToColorEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageToColorEnable);
+    dump_function_head(api_dump, "vkCmdSetCoverageToColorEnableNV", "commandBuffer, coverageToColorEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoverageToColorEnableNV(api_dump, commandBuffer, coverageToColorEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoverageToColorEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageToColorEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoverageToColorEnableNV(api_dump, commandBuffer, coverageToColorEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageToColorLocationNV", "commandBuffer, coverageToColorLocation", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoverageToColorLocationNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageToColorLocation);
+    dump_function_head(api_dump, "vkCmdSetCoverageToColorLocationNV", "commandBuffer, coverageToColorLocation", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoverageToColorLocationNV(api_dump, commandBuffer, coverageToColorLocation);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoverageToColorLocationNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageToColorLocation);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoverageToColorLocationNV(api_dump, commandBuffer, coverageToColorLocation);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageModulationModeNV", "commandBuffer, coverageModulationMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoverageModulationModeNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageModulationMode);
+    dump_function_head(api_dump, "vkCmdSetCoverageModulationModeNV", "commandBuffer, coverageModulationMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoverageModulationModeNV(api_dump, commandBuffer, coverageModulationMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoverageModulationModeNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageModulationMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoverageModulationModeNV(api_dump, commandBuffer, coverageModulationMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageModulationTableEnableNV", "commandBuffer, coverageModulationTableEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoverageModulationTableEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageModulationTableEnable);
+    dump_function_head(api_dump, "vkCmdSetCoverageModulationTableEnableNV", "commandBuffer, coverageModulationTableEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoverageModulationTableEnableNV(api_dump, commandBuffer, coverageModulationTableEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoverageModulationTableEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageModulationTableEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoverageModulationTableEnableNV(api_dump, commandBuffer, coverageModulationTableEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageModulationTableNV", "commandBuffer, coverageModulationTableCount, pCoverageModulationTable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoverageModulationTableNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageModulationTableCount, pCoverageModulationTable);
+    dump_function_head(api_dump, "vkCmdSetCoverageModulationTableNV", "commandBuffer, coverageModulationTableCount, pCoverageModulationTable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoverageModulationTableNV(api_dump, commandBuffer, coverageModulationTableCount, pCoverageModulationTable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoverageModulationTableNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageModulationTableCount, pCoverageModulationTable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoverageModulationTableNV(api_dump, commandBuffer, coverageModulationTableCount, pCoverageModulationTable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetShadingRateImageEnableNV", "commandBuffer, shadingRateImageEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetShadingRateImageEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, shadingRateImageEnable);
+    dump_function_head(api_dump, "vkCmdSetShadingRateImageEnableNV", "commandBuffer, shadingRateImageEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetShadingRateImageEnableNV(api_dump, commandBuffer, shadingRateImageEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetShadingRateImageEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, shadingRateImageEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetShadingRateImageEnableNV(api_dump, commandBuffer, shadingRateImageEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRepresentativeFragmentTestEnableNV", "commandBuffer, representativeFragmentTestEnable", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRepresentativeFragmentTestEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, representativeFragmentTestEnable);
+    dump_function_head(api_dump, "vkCmdSetRepresentativeFragmentTestEnableNV", "commandBuffer, representativeFragmentTestEnable", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(api_dump, commandBuffer, representativeFragmentTestEnable);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRepresentativeFragmentTestEnableNV<Format>(ApiDumpInstance::current(), commandBuffer, representativeFragmentTestEnable);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(api_dump, commandBuffer, representativeFragmentTestEnable);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageReductionModeNV", "commandBuffer, coverageReductionMode", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetCoverageReductionModeNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageReductionMode);
+    dump_function_head(api_dump, "vkCmdSetCoverageReductionModeNV", "commandBuffer, coverageReductionMode", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetCoverageReductionModeNV(api_dump, commandBuffer, coverageReductionMode);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetCoverageReductionModeNV<Format>(ApiDumpInstance::current(), commandBuffer, coverageReductionMode);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetCoverageReductionModeNV(api_dump, commandBuffer, coverageReductionMode);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateTensorARM", "device, pCreateInfo, pAllocator, pTensor", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateTensorARM<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pTensor);
+    dump_function_head(api_dump, "vkCreateTensorARM", "device, pCreateInfo, pAllocator, pTensor", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateTensorARM(api_dump, device, pCreateInfo, pAllocator, pTensor);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateTensorARM(device, pCreateInfo, pAllocator, pTensor);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateTensorARM<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pTensor);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateTensorARM(api_dump, device, pCreateInfo, pAllocator, pTensor);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyTensorARM", "device, tensor, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyTensorARM<Format>(ApiDumpInstance::current(), device, tensor, pAllocator);
+    dump_function_head(api_dump, "vkDestroyTensorARM", "device, tensor, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyTensorARM(api_dump, device, tensor, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyTensorARM(device, tensor, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyTensorARM<Format>(ApiDumpInstance::current(), device, tensor, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyTensorARM(api_dump, device, tensor, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateTensorViewARM", "device, pCreateInfo, pAllocator, pView", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateTensorViewARM<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView);
+    dump_function_head(api_dump, "vkCreateTensorViewARM", "device, pCreateInfo, pAllocator, pView", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateTensorViewARM(api_dump, device, pCreateInfo, pAllocator, pView);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateTensorViewARM(device, pCreateInfo, pAllocator, pView);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateTensorViewARM<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateTensorViewARM(api_dump, device, pCreateInfo, pAllocator, pView);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyTensorViewARM", "device, tensorView, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyTensorViewARM<Format>(ApiDumpInstance::current(), device, tensorView, pAllocator);
+    dump_function_head(api_dump, "vkDestroyTensorViewARM", "device, tensorView, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyTensorViewARM(api_dump, device, tensorView, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyTensorViewARM(device, tensorView, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyTensorViewARM<Format>(ApiDumpInstance::current(), device, tensorView, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyTensorViewARM(api_dump, device, tensorView, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetTensorMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetTensorMemoryRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetTensorMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetTensorMemoryRequirementsARM(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetTensorMemoryRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetTensorMemoryRequirementsARM(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindTensorMemoryARM", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindTensorMemoryARM<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindTensorMemoryARM", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindTensorMemoryARM(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindTensorMemoryARM(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindTensorMemoryARM<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindTensorMemoryARM(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceTensorMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceTensorMemoryRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDeviceTensorMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceTensorMemoryRequirementsARM(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceTensorMemoryRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceTensorMemoryRequirementsARM(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyTensorARM", "commandBuffer, pCopyTensorInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyTensorARM<Format>(ApiDumpInstance::current(), commandBuffer, pCopyTensorInfo);
+    dump_function_head(api_dump, "vkCmdCopyTensorARM", "commandBuffer, pCopyTensorInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyTensorARM(api_dump, commandBuffer, pCopyTensorInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyTensorARM(commandBuffer, pCopyTensorInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyTensorARM<Format>(ApiDumpInstance::current(), commandBuffer, pCopyTensorInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyTensorARM(api_dump, commandBuffer, pCopyTensorInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetTensorOpaqueCaptureDescriptorDataARM", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetTensorOpaqueCaptureDescriptorDataARM", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetTensorViewOpaqueCaptureDescriptorDataARM", "device, pInfo, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM<Format>(ApiDumpInstance::current(), device, pInfo, pData);
+    dump_function_head(api_dump, "vkGetTensorViewOpaqueCaptureDescriptorDataARM", "device, pInfo, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(api_dump, device, pInfo, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM(device, pInfo, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM<Format>(ApiDumpInstance::current(), device, pInfo, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(api_dump, device, pInfo, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetShaderModuleIdentifierEXT", "device, shaderModule, pIdentifier", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetShaderModuleIdentifierEXT<Format>(ApiDumpInstance::current(), device, shaderModule, pIdentifier);
+    dump_function_head(api_dump, "vkGetShaderModuleIdentifierEXT", "device, shaderModule, pIdentifier", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetShaderModuleIdentifierEXT(api_dump, device, shaderModule, pIdentifier);
         }
     }
     device_dispatch_table(device)->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetShaderModuleIdentifierEXT<Format>(ApiDumpInstance::current(), device, shaderModule, pIdentifier);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetShaderModuleIdentifierEXT(api_dump, device, shaderModule, pIdentifier);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetShaderModuleCreateInfoIdentifierEXT", "device, pCreateInfo, pIdentifier", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetShaderModuleCreateInfoIdentifierEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pIdentifier);
+    dump_function_head(api_dump, "vkGetShaderModuleCreateInfoIdentifierEXT", "device, pCreateInfo, pIdentifier", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(api_dump, device, pCreateInfo, pIdentifier);
         }
     }
     device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetShaderModuleCreateInfoIdentifierEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pIdentifier);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(api_dump, device, pCreateInfo, pIdentifier);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateOpticalFlowSessionNV", "device, pCreateInfo, pAllocator, pSession", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateOpticalFlowSessionNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession);
+    dump_function_head(api_dump, "vkCreateOpticalFlowSessionNV", "device, pCreateInfo, pAllocator, pSession", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateOpticalFlowSessionNV(api_dump, device, pCreateInfo, pAllocator, pSession);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateOpticalFlowSessionNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateOpticalFlowSessionNV(api_dump, device, pCreateInfo, pAllocator, pSession);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyOpticalFlowSessionNV", "device, session, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyOpticalFlowSessionNV<Format>(ApiDumpInstance::current(), device, session, pAllocator);
+    dump_function_head(api_dump, "vkDestroyOpticalFlowSessionNV", "device, session, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyOpticalFlowSessionNV(api_dump, device, session, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyOpticalFlowSessionNV(device, session, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyOpticalFlowSessionNV<Format>(ApiDumpInstance::current(), device, session, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyOpticalFlowSessionNV(api_dump, device, session, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindOpticalFlowSessionImageNV", "device, session, bindingPoint, view, layout", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindOpticalFlowSessionImageNV<Format>(ApiDumpInstance::current(), device, session, bindingPoint, view, layout);
+    dump_function_head(api_dump, "vkBindOpticalFlowSessionImageNV", "device, session, bindingPoint, view, layout", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindOpticalFlowSessionImageNV(api_dump, device, session, bindingPoint, view, layout);
         }
     }
     VkResult result = device_dispatch_table(device)->BindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindOpticalFlowSessionImageNV<Format>(ApiDumpInstance::current(), device, session, bindingPoint, view, layout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindOpticalFlowSessionImageNV(api_dump, device, session, bindingPoint, view, layout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdOpticalFlowExecuteNV", "commandBuffer, session, pExecuteInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdOpticalFlowExecuteNV<Format>(ApiDumpInstance::current(), commandBuffer, session, pExecuteInfo);
+    dump_function_head(api_dump, "vkCmdOpticalFlowExecuteNV", "commandBuffer, session, pExecuteInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdOpticalFlowExecuteNV(api_dump, commandBuffer, session, pExecuteInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdOpticalFlowExecuteNV<Format>(ApiDumpInstance::current(), commandBuffer, session, pExecuteInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdOpticalFlowExecuteNV(api_dump, commandBuffer, session, pExecuteInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkAntiLagUpdateAMD", "device, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkAntiLagUpdateAMD<Format>(ApiDumpInstance::current(), device, pData);
+    dump_function_head(api_dump, "vkAntiLagUpdateAMD", "device, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkAntiLagUpdateAMD(api_dump, device, pData);
         }
     }
     device_dispatch_table(device)->AntiLagUpdateAMD(device, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkAntiLagUpdateAMD<Format>(ApiDumpInstance::current(), device, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkAntiLagUpdateAMD(api_dump, device, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateShadersEXT", "device, createInfoCount, pCreateInfos, pAllocator, pShaders", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateShadersEXT<Format>(ApiDumpInstance::current(), device, createInfoCount, pCreateInfos, pAllocator, pShaders);
+    dump_function_head(api_dump, "vkCreateShadersEXT", "device, createInfoCount, pCreateInfos, pAllocator, pShaders", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateShadersEXT(api_dump, device, createInfoCount, pCreateInfos, pAllocator, pShaders);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateShadersEXT<Format>(ApiDumpInstance::current(), device, createInfoCount, pCreateInfos, pAllocator, pShaders);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateShadersEXT(api_dump, device, createInfoCount, pCreateInfos, pAllocator, pShaders);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyShaderEXT", "device, shader, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyShaderEXT<Format>(ApiDumpInstance::current(), device, shader, pAllocator);
+    dump_function_head(api_dump, "vkDestroyShaderEXT", "device, shader, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyShaderEXT(api_dump, device, shader, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyShaderEXT(device, shader, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyShaderEXT<Format>(ApiDumpInstance::current(), device, shader, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyShaderEXT(api_dump, device, shader, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetShaderBinaryDataEXT", "device, shader, pDataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetShaderBinaryDataEXT<Format>(ApiDumpInstance::current(), device, shader, pDataSize, pData);
+    dump_function_head(api_dump, "vkGetShaderBinaryDataEXT", "device, shader, pDataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetShaderBinaryDataEXT(api_dump, device, shader, pDataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetShaderBinaryDataEXT(device, shader, pDataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetShaderBinaryDataEXT<Format>(ApiDumpInstance::current(), device, shader, pDataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetShaderBinaryDataEXT(api_dump, device, shader, pDataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindShadersEXT", "commandBuffer, stageCount, pStages, pShaders", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindShadersEXT<Format>(ApiDumpInstance::current(), commandBuffer, stageCount, pStages, pShaders);
+    dump_function_head(api_dump, "vkCmdBindShadersEXT", "commandBuffer, stageCount, pStages, pShaders", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindShadersEXT(api_dump, commandBuffer, stageCount, pStages, pShaders);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindShadersEXT<Format>(ApiDumpInstance::current(), commandBuffer, stageCount, pStages, pShaders);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindShadersEXT(api_dump, commandBuffer, stageCount, pStages, pShaders);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClampRangeEXT", "commandBuffer, depthClampMode, pDepthClampRange", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetDepthClampRangeEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthClampMode, pDepthClampRange);
+    dump_function_head(api_dump, "vkCmdSetDepthClampRangeEXT", "commandBuffer, depthClampMode, pDepthClampRange", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetDepthClampRangeEXT(api_dump, commandBuffer, depthClampMode, pDepthClampRange);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetDepthClampRangeEXT<Format>(ApiDumpInstance::current(), commandBuffer, depthClampMode, pDepthClampRange);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetDepthClampRangeEXT(api_dump, commandBuffer, depthClampMode, pDepthClampRange);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetFramebufferTilePropertiesQCOM", "device, framebuffer, pPropertiesCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetFramebufferTilePropertiesQCOM<Format>(ApiDumpInstance::current(), device, framebuffer, pPropertiesCount, pProperties);
+    dump_function_head(api_dump, "vkGetFramebufferTilePropertiesQCOM", "device, framebuffer, pPropertiesCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetFramebufferTilePropertiesQCOM(api_dump, device, framebuffer, pPropertiesCount, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetFramebufferTilePropertiesQCOM<Format>(ApiDumpInstance::current(), device, framebuffer, pPropertiesCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetFramebufferTilePropertiesQCOM(api_dump, device, framebuffer, pPropertiesCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDynamicRenderingTilePropertiesQCOM", "device, pRenderingInfo, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDynamicRenderingTilePropertiesQCOM<Format>(ApiDumpInstance::current(), device, pRenderingInfo, pProperties);
+    dump_function_head(api_dump, "vkGetDynamicRenderingTilePropertiesQCOM", "device, pRenderingInfo, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDynamicRenderingTilePropertiesQCOM(api_dump, device, pRenderingInfo, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDynamicRenderingTilePropertiesQCOM<Format>(ApiDumpInstance::current(), device, pRenderingInfo, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDynamicRenderingTilePropertiesQCOM(api_dump, device, pRenderingInfo, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkConvertCooperativeVectorMatrixNV", "device, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkConvertCooperativeVectorMatrixNV<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkConvertCooperativeVectorMatrixNV", "device, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkConvertCooperativeVectorMatrixNV(api_dump, device, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkConvertCooperativeVectorMatrixNV<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkConvertCooperativeVectorMatrixNV(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdConvertCooperativeVectorMatrixNV", "commandBuffer, infoCount, pInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdConvertCooperativeVectorMatrixNV<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos);
+    dump_function_head(api_dump, "vkCmdConvertCooperativeVectorMatrixNV", "commandBuffer, infoCount, pInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdConvertCooperativeVectorMatrixNV(api_dump, commandBuffer, infoCount, pInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdConvertCooperativeVectorMatrixNV(commandBuffer, infoCount, pInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdConvertCooperativeVectorMatrixNV<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdConvertCooperativeVectorMatrixNV(api_dump, commandBuffer, infoCount, pInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetLatencySleepModeNV", "device, swapchain, pSleepModeInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetLatencySleepModeNV<Format>(ApiDumpInstance::current(), device, swapchain, pSleepModeInfo);
+    dump_function_head(api_dump, "vkSetLatencySleepModeNV", "device, swapchain, pSleepModeInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetLatencySleepModeNV(api_dump, device, swapchain, pSleepModeInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->SetLatencySleepModeNV(device, swapchain, pSleepModeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetLatencySleepModeNV<Format>(ApiDumpInstance::current(), device, swapchain, pSleepModeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetLatencySleepModeNV(api_dump, device, swapchain, pSleepModeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkLatencySleepNV", "device, swapchain, pSleepInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkLatencySleepNV<Format>(ApiDumpInstance::current(), device, swapchain, pSleepInfo);
+    dump_function_head(api_dump, "vkLatencySleepNV", "device, swapchain, pSleepInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkLatencySleepNV(api_dump, device, swapchain, pSleepInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->LatencySleepNV(device, swapchain, pSleepInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkLatencySleepNV<Format>(ApiDumpInstance::current(), device, swapchain, pSleepInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkLatencySleepNV(api_dump, device, swapchain, pSleepInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkSetLatencyMarkerNV", "device, swapchain, pLatencyMarkerInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkSetLatencyMarkerNV<Format>(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo);
+    dump_function_head(api_dump, "vkSetLatencyMarkerNV", "device, swapchain, pLatencyMarkerInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkSetLatencyMarkerNV(api_dump, device, swapchain, pLatencyMarkerInfo);
         }
     }
     device_dispatch_table(device)->SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkSetLatencyMarkerNV<Format>(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkSetLatencyMarkerNV(api_dump, device, swapchain, pLatencyMarkerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetLatencyTimingsNV", "device, swapchain, pLatencyMarkerInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetLatencyTimingsNV<Format>(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo);
+    dump_function_head(api_dump, "vkGetLatencyTimingsNV", "device, swapchain, pLatencyMarkerInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetLatencyTimingsNV(api_dump, device, swapchain, pLatencyMarkerInfo);
         }
     }
     device_dispatch_table(device)->GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetLatencyTimingsNV<Format>(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetLatencyTimingsNV(api_dump, device, swapchain, pLatencyMarkerInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkQueueNotifyOutOfBandNV", "queue, pQueueTypeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkQueueNotifyOutOfBandNV<Format>(ApiDumpInstance::current(), queue, pQueueTypeInfo);
+    dump_function_head(api_dump, "vkQueueNotifyOutOfBandNV", "queue, pQueueTypeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkQueueNotifyOutOfBandNV(api_dump, queue, pQueueTypeInfo);
         }
     }
     device_dispatch_table(queue)->QueueNotifyOutOfBandNV(queue, pQueueTypeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkQueueNotifyOutOfBandNV<Format>(ApiDumpInstance::current(), queue, pQueueTypeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkQueueNotifyOutOfBandNV(api_dump, queue, pQueueTypeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDataGraphPipelinesARM", "device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDataGraphPipelinesARM<Format>(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    dump_function_head(api_dump, "vkCreateDataGraphPipelinesARM", "device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDataGraphPipelinesARM(api_dump, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDataGraphPipelinesARM(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDataGraphPipelinesARM<Format>(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDataGraphPipelinesARM(api_dump, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateDataGraphPipelineSessionARM", "device, pCreateInfo, pAllocator, pSession", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateDataGraphPipelineSessionARM<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession);
+    dump_function_head(api_dump, "vkCreateDataGraphPipelineSessionARM", "device, pCreateInfo, pAllocator, pSession", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateDataGraphPipelineSessionARM(api_dump, device, pCreateInfo, pAllocator, pSession);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateDataGraphPipelineSessionARM(device, pCreateInfo, pAllocator, pSession);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateDataGraphPipelineSessionARM<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateDataGraphPipelineSessionARM(api_dump, device, pCreateInfo, pAllocator, pSession);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelineSessionBindPointRequirementsARM", "device, pInfo, pBindPointRequirementCount, pBindPointRequirements", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pBindPointRequirementCount, pBindPointRequirements);
+    dump_function_head(api_dump, "vkGetDataGraphPipelineSessionBindPointRequirementsARM", "device, pInfo, pBindPointRequirementCount, pBindPointRequirements", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(api_dump, device, pInfo, pBindPointRequirementCount, pBindPointRequirements);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM(device, pInfo, pBindPointRequirementCount, pBindPointRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pBindPointRequirementCount, pBindPointRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(api_dump, device, pInfo, pBindPointRequirementCount, pBindPointRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelineSessionMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetDataGraphPipelineSessionMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBindDataGraphPipelineSessionMemoryARM", "device, bindInfoCount, pBindInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBindDataGraphPipelineSessionMemoryARM<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
+    dump_function_head(api_dump, "vkBindDataGraphPipelineSessionMemoryARM", "device, bindInfoCount, pBindInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBindDataGraphPipelineSessionMemoryARM(api_dump, device, bindInfoCount, pBindInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM(device, bindInfoCount, pBindInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBindDataGraphPipelineSessionMemoryARM<Format>(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBindDataGraphPipelineSessionMemoryARM(api_dump, device, bindInfoCount, pBindInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyDataGraphPipelineSessionARM", "device, session, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyDataGraphPipelineSessionARM<Format>(ApiDumpInstance::current(), device, session, pAllocator);
+    dump_function_head(api_dump, "vkDestroyDataGraphPipelineSessionARM", "device, session, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyDataGraphPipelineSessionARM(api_dump, device, session, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM(device, session, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyDataGraphPipelineSessionARM<Format>(ApiDumpInstance::current(), device, session, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyDataGraphPipelineSessionARM(api_dump, device, session, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchDataGraphARM", "commandBuffer, session, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDispatchDataGraphARM<Format>(ApiDumpInstance::current(), commandBuffer, session, pInfo);
+    dump_function_head(api_dump, "vkCmdDispatchDataGraphARM", "commandBuffer, session, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDispatchDataGraphARM(api_dump, commandBuffer, session, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDispatchDataGraphARM(commandBuffer, session, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDispatchDataGraphARM<Format>(ApiDumpInstance::current(), commandBuffer, session, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDispatchDataGraphARM(api_dump, commandBuffer, session, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelineAvailablePropertiesARM", "device, pPipelineInfo, pPropertiesCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDataGraphPipelineAvailablePropertiesARM<Format>(ApiDumpInstance::current(), device, pPipelineInfo, pPropertiesCount, pProperties);
+    dump_function_head(api_dump, "vkGetDataGraphPipelineAvailablePropertiesARM", "device, pPipelineInfo, pPropertiesCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(api_dump, device, pPipelineInfo, pPropertiesCount, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM(device, pPipelineInfo, pPropertiesCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDataGraphPipelineAvailablePropertiesARM<Format>(ApiDumpInstance::current(), device, pPipelineInfo, pPropertiesCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(api_dump, device, pPipelineInfo, pPropertiesCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelinePropertiesARM", "device, pPipelineInfo, propertiesCount, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDataGraphPipelinePropertiesARM<Format>(ApiDumpInstance::current(), device, pPipelineInfo, propertiesCount, pProperties);
+    dump_function_head(api_dump, "vkGetDataGraphPipelinePropertiesARM", "device, pPipelineInfo, propertiesCount, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDataGraphPipelinePropertiesARM(api_dump, device, pPipelineInfo, propertiesCount, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM(device, pPipelineInfo, propertiesCount, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDataGraphPipelinePropertiesARM<Format>(ApiDumpInstance::current(), device, pPipelineInfo, propertiesCount, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDataGraphPipelinePropertiesARM(api_dump, device, pPipelineInfo, propertiesCount, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetAttachmentFeedbackLoopEnableEXT", "commandBuffer, aspectMask", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, aspectMask);
+    dump_function_head(api_dump, "vkCmdSetAttachmentFeedbackLoopEnableEXT", "commandBuffer, aspectMask", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(api_dump, commandBuffer, aspectMask);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT<Format>(ApiDumpInstance::current(), commandBuffer, aspectMask);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(api_dump, commandBuffer, aspectMask);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetScreenBufferPropertiesQNX", "device, buffer, pProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetScreenBufferPropertiesQNX<Format>(ApiDumpInstance::current(), device, buffer, pProperties);
+    dump_function_head(api_dump, "vkGetScreenBufferPropertiesQNX", "device, buffer, pProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetScreenBufferPropertiesQNX(api_dump, device, buffer, pProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetScreenBufferPropertiesQNX(device, buffer, pProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetScreenBufferPropertiesQNX<Format>(ApiDumpInstance::current(), device, buffer, pProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetScreenBufferPropertiesQNX(api_dump, device, buffer, pProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBindTileMemoryQCOM", "commandBuffer, pTileMemoryBindInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBindTileMemoryQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pTileMemoryBindInfo);
+    dump_function_head(api_dump, "vkCmdBindTileMemoryQCOM", "commandBuffer, pTileMemoryBindInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBindTileMemoryQCOM(api_dump, commandBuffer, pTileMemoryBindInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBindTileMemoryQCOM(commandBuffer, pTileMemoryBindInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBindTileMemoryQCOM<Format>(ApiDumpInstance::current(), commandBuffer, pTileMemoryBindInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBindTileMemoryQCOM(api_dump, commandBuffer, pTileMemoryBindInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryEXT", "commandBuffer, pDecompressMemoryInfoEXT", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDecompressMemoryEXT<Format>(ApiDumpInstance::current(), commandBuffer, pDecompressMemoryInfoEXT);
+    dump_function_head(api_dump, "vkCmdDecompressMemoryEXT", "commandBuffer, pDecompressMemoryInfoEXT", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDecompressMemoryEXT(api_dump, commandBuffer, pDecompressMemoryInfoEXT);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDecompressMemoryEXT(commandBuffer, pDecompressMemoryInfoEXT);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDecompressMemoryEXT<Format>(ApiDumpInstance::current(), commandBuffer, pDecompressMemoryInfoEXT);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDecompressMemoryEXT(api_dump, commandBuffer, pDecompressMemoryInfoEXT);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryIndirectCountEXT", "commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDecompressMemoryIndirectCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride);
+    dump_function_head(api_dump, "vkCmdDecompressMemoryIndirectCountEXT", "commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDecompressMemoryIndirectCountEXT(api_dump, commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountEXT(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDecompressMemoryIndirectCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDecompressMemoryIndirectCountEXT(api_dump, commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateExternalComputeQueueNV", "device, pCreateInfo, pAllocator, pExternalQueue", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateExternalComputeQueueNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pExternalQueue);
+    dump_function_head(api_dump, "vkCreateExternalComputeQueueNV", "device, pCreateInfo, pAllocator, pExternalQueue", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateExternalComputeQueueNV(api_dump, device, pCreateInfo, pAllocator, pExternalQueue);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateExternalComputeQueueNV(device, pCreateInfo, pAllocator, pExternalQueue);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateExternalComputeQueueNV<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pExternalQueue);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateExternalComputeQueueNV(api_dump, device, pCreateInfo, pAllocator, pExternalQueue);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyExternalComputeQueueNV", "device, externalQueue, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyExternalComputeQueueNV<Format>(ApiDumpInstance::current(), device, externalQueue, pAllocator);
+    dump_function_head(api_dump, "vkDestroyExternalComputeQueueNV", "device, externalQueue, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyExternalComputeQueueNV(api_dump, device, externalQueue, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyExternalComputeQueueNV(device, externalQueue, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyExternalComputeQueueNV<Format>(ApiDumpInstance::current(), device, externalQueue, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyExternalComputeQueueNV(api_dump, device, externalQueue, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetExternalComputeQueueDataNV", "externalQueue, params, pData", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetExternalComputeQueueDataNV<Format>(ApiDumpInstance::current(), externalQueue, params, pData);
+    dump_function_head(api_dump, "vkGetExternalComputeQueueDataNV", "externalQueue, params, pData", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetExternalComputeQueueDataNV(api_dump, externalQueue, params, pData);
         }
     }
     device_dispatch_table(externalQueue)->GetExternalComputeQueueDataNV(externalQueue, params, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetExternalComputeQueueDataNV<Format>(ApiDumpInstance::current(), externalQueue, params, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetExternalComputeQueueDataNV(api_dump, externalQueue, params, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetClusterAccelerationStructureBuildSizesNV", "device, pInfo, pSizeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetClusterAccelerationStructureBuildSizesNV<Format>(ApiDumpInstance::current(), device, pInfo, pSizeInfo);
+    dump_function_head(api_dump, "vkGetClusterAccelerationStructureBuildSizesNV", "device, pInfo, pSizeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetClusterAccelerationStructureBuildSizesNV(api_dump, device, pInfo, pSizeInfo);
         }
     }
     device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV(device, pInfo, pSizeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetClusterAccelerationStructureBuildSizesNV<Format>(ApiDumpInstance::current(), device, pInfo, pSizeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetClusterAccelerationStructureBuildSizesNV(api_dump, device, pInfo, pSizeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBuildClusterAccelerationStructureIndirectNV", "commandBuffer, pCommandInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, pCommandInfos);
+    dump_function_head(api_dump, "vkCmdBuildClusterAccelerationStructureIndirectNV", "commandBuffer, pCommandInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(api_dump, commandBuffer, pCommandInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBuildClusterAccelerationStructureIndirectNV(commandBuffer, pCommandInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV<Format>(ApiDumpInstance::current(), commandBuffer, pCommandInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(api_dump, commandBuffer, pCommandInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetPartitionedAccelerationStructuresBuildSizesNV", "device, pInfo, pSizeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV<Format>(ApiDumpInstance::current(), device, pInfo, pSizeInfo);
+    dump_function_head(api_dump, "vkGetPartitionedAccelerationStructuresBuildSizesNV", "device, pInfo, pSizeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(api_dump, device, pInfo, pSizeInfo);
         }
     }
     device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV(device, pInfo, pSizeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV<Format>(ApiDumpInstance::current(), device, pInfo, pSizeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(api_dump, device, pInfo, pSizeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBuildPartitionedAccelerationStructuresNV", "commandBuffer, pBuildInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBuildPartitionedAccelerationStructuresNV<Format>(ApiDumpInstance::current(), commandBuffer, pBuildInfo);
+    dump_function_head(api_dump, "vkCmdBuildPartitionedAccelerationStructuresNV", "commandBuffer, pBuildInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(api_dump, commandBuffer, pBuildInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBuildPartitionedAccelerationStructuresNV(commandBuffer, pBuildInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBuildPartitionedAccelerationStructuresNV<Format>(ApiDumpInstance::current(), commandBuffer, pBuildInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(api_dump, commandBuffer, pBuildInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetGeneratedCommandsMemoryRequirementsEXT", "device, pInfo, pMemoryRequirements", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
+    dump_function_head(api_dump, "vkGetGeneratedCommandsMemoryRequirementsEXT", "device, pInfo, pMemoryRequirements", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(api_dump, device, pInfo, pMemoryRequirements);
         }
     }
     device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, pMemoryRequirements);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT<Format>(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(api_dump, device, pInfo, pMemoryRequirements);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdPreprocessGeneratedCommandsEXT", "commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdPreprocessGeneratedCommandsEXT<Format>(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer);
+    dump_function_head(api_dump, "vkCmdPreprocessGeneratedCommandsEXT", "commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdPreprocessGeneratedCommandsEXT(api_dump, commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer);
         }
     }
     device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdPreprocessGeneratedCommandsEXT<Format>(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdPreprocessGeneratedCommandsEXT(api_dump, commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdExecuteGeneratedCommandsEXT", "commandBuffer, isPreprocessed, pGeneratedCommandsInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdExecuteGeneratedCommandsEXT<Format>(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
+    dump_function_head(api_dump, "vkCmdExecuteGeneratedCommandsEXT", "commandBuffer, isPreprocessed, pGeneratedCommandsInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdExecuteGeneratedCommandsEXT(api_dump, commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdExecuteGeneratedCommandsEXT<Format>(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdExecuteGeneratedCommandsEXT(api_dump, commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateIndirectCommandsLayoutEXT", "device, pCreateInfo, pAllocator, pIndirectCommandsLayout", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateIndirectCommandsLayoutEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+    dump_function_head(api_dump, "vkCreateIndirectCommandsLayoutEXT", "device, pCreateInfo, pAllocator, pIndirectCommandsLayout", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateIndirectCommandsLayoutEXT(api_dump, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateIndirectCommandsLayoutEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateIndirectCommandsLayoutEXT(api_dump, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyIndirectCommandsLayoutEXT", "device, indirectCommandsLayout, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyIndirectCommandsLayoutEXT<Format>(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator);
+    dump_function_head(api_dump, "vkDestroyIndirectCommandsLayoutEXT", "device, indirectCommandsLayout, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyIndirectCommandsLayoutEXT(api_dump, device, indirectCommandsLayout, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyIndirectCommandsLayoutEXT<Format>(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyIndirectCommandsLayoutEXT(api_dump, device, indirectCommandsLayout, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateIndirectExecutionSetEXT", "device, pCreateInfo, pAllocator, pIndirectExecutionSet", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateIndirectExecutionSetEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectExecutionSet);
+    dump_function_head(api_dump, "vkCreateIndirectExecutionSetEXT", "device, pCreateInfo, pAllocator, pIndirectExecutionSet", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateIndirectExecutionSetEXT(api_dump, device, pCreateInfo, pAllocator, pIndirectExecutionSet);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateIndirectExecutionSetEXT<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectExecutionSet);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateIndirectExecutionSetEXT(api_dump, device, pCreateInfo, pAllocator, pIndirectExecutionSet);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyIndirectExecutionSetEXT", "device, indirectExecutionSet, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyIndirectExecutionSetEXT<Format>(ApiDumpInstance::current(), device, indirectExecutionSet, pAllocator);
+    dump_function_head(api_dump, "vkDestroyIndirectExecutionSetEXT", "device, indirectExecutionSet, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyIndirectExecutionSetEXT(api_dump, device, indirectExecutionSet, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyIndirectExecutionSetEXT<Format>(ApiDumpInstance::current(), device, indirectExecutionSet, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyIndirectExecutionSetEXT(api_dump, device, indirectExecutionSet, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUpdateIndirectExecutionSetPipelineEXT", "device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUpdateIndirectExecutionSetPipelineEXT<Format>(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
+    dump_function_head(api_dump, "vkUpdateIndirectExecutionSetPipelineEXT", "device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUpdateIndirectExecutionSetPipelineEXT(api_dump, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
         }
     }
     device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUpdateIndirectExecutionSetPipelineEXT<Format>(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUpdateIndirectExecutionSetPipelineEXT(api_dump, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkUpdateIndirectExecutionSetShaderEXT", "device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkUpdateIndirectExecutionSetShaderEXT<Format>(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
+    dump_function_head(api_dump, "vkUpdateIndirectExecutionSetShaderEXT", "device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkUpdateIndirectExecutionSetShaderEXT(api_dump, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
         }
     }
     device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkUpdateIndirectExecutionSetShaderEXT<Format>(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkUpdateIndirectExecutionSetShaderEXT(api_dump, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #if defined(VK_USE_PLATFORM_METAL_EXT)
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryMetalHandleEXT", "device, pGetMetalHandleInfo, pHandle", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryMetalHandleEXT<Format>(ApiDumpInstance::current(), device, pGetMetalHandleInfo, pHandle);
+    dump_function_head(api_dump, "vkGetMemoryMetalHandleEXT", "device, pGetMetalHandleInfo, pHandle", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryMetalHandleEXT(api_dump, device, pGetMetalHandleInfo, pHandle);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryMetalHandleEXT<Format>(ApiDumpInstance::current(), device, pGetMetalHandleInfo, pHandle);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryMetalHandleEXT(api_dump, device, pGetMetalHandleInfo, pHandle);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetMemoryMetalHandlePropertiesEXT", "device, handleType, pHandle, pMemoryMetalHandleProperties", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetMemoryMetalHandlePropertiesEXT<Format>(ApiDumpInstance::current(), device, handleType, pHandle, pMemoryMetalHandleProperties);
+    dump_function_head(api_dump, "vkGetMemoryMetalHandlePropertiesEXT", "device, handleType, pHandle, pMemoryMetalHandleProperties", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetMemoryMetalHandlePropertiesEXT(api_dump, device, handleType, pHandle, pMemoryMetalHandleProperties);
         }
     }
     VkResult result = device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetMemoryMetalHandlePropertiesEXT<Format>(ApiDumpInstance::current(), device, handleType, pHandle, pMemoryMetalHandleProperties);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetMemoryMetalHandlePropertiesEXT(api_dump, device, handleType, pHandle, pMemoryMetalHandleProperties);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
 #endif  // VK_USE_PLATFORM_METAL_EXT
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdEndRendering2EXT", "commandBuffer, pRenderingEndInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdEndRendering2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo);
+    dump_function_head(api_dump, "vkCmdEndRendering2EXT", "commandBuffer, pRenderingEndInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdEndRendering2EXT(api_dump, commandBuffer, pRenderingEndInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdEndRendering2EXT(commandBuffer, pRenderingEndInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdEndRendering2EXT<Format>(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdEndRendering2EXT(api_dump, commandBuffer, pRenderingEndInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBeginCustomResolveEXT", "commandBuffer, pBeginCustomResolveInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBeginCustomResolveEXT<Format>(ApiDumpInstance::current(), commandBuffer, pBeginCustomResolveInfo);
+    dump_function_head(api_dump, "vkCmdBeginCustomResolveEXT", "commandBuffer, pBeginCustomResolveInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBeginCustomResolveEXT(api_dump, commandBuffer, pBeginCustomResolveInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBeginCustomResolveEXT<Format>(ApiDumpInstance::current(), commandBuffer, pBeginCustomResolveInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBeginCustomResolveEXT(api_dump, commandBuffer, pBeginCustomResolveInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetComputeOccupancyPriorityNV", "commandBuffer, pParameters", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetComputeOccupancyPriorityNV<Format>(ApiDumpInstance::current(), commandBuffer, pParameters);
+    dump_function_head(api_dump, "vkCmdSetComputeOccupancyPriorityNV", "commandBuffer, pParameters", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetComputeOccupancyPriorityNV(api_dump, commandBuffer, pParameters);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetComputeOccupancyPriorityNV(commandBuffer, pParameters);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetComputeOccupancyPriorityNV<Format>(ApiDumpInstance::current(), commandBuffer, pParameters);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetComputeOccupancyPriorityNV(api_dump, commandBuffer, pParameters);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateAccelerationStructureKHR", "device, pCreateInfo, pAllocator, pAccelerationStructure", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure);
+    dump_function_head(api_dump, "vkCreateAccelerationStructureKHR", "device, pCreateInfo, pAllocator, pAccelerationStructure", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateAccelerationStructureKHR(api_dump, device, pCreateInfo, pAllocator, pAccelerationStructure);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateAccelerationStructureKHR(api_dump, device, pCreateInfo, pAllocator, pAccelerationStructure);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkDestroyAccelerationStructureKHR", "device, accelerationStructure, pAllocator", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkDestroyAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, accelerationStructure, pAllocator);
+    dump_function_head(api_dump, "vkDestroyAccelerationStructureKHR", "device, accelerationStructure, pAllocator", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkDestroyAccelerationStructureKHR(api_dump, device, accelerationStructure, pAllocator);
         }
     }
     device_dispatch_table(device)->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkDestroyAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, accelerationStructure, pAllocator);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkDestroyAccelerationStructureKHR(api_dump, device, accelerationStructure, pAllocator);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBuildAccelerationStructuresKHR", "commandBuffer, infoCount, pInfos, ppBuildRangeInfos", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBuildAccelerationStructuresKHR<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
+    dump_function_head(api_dump, "vkCmdBuildAccelerationStructuresKHR", "commandBuffer, infoCount, pInfos, ppBuildRangeInfos", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBuildAccelerationStructuresKHR(api_dump, commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBuildAccelerationStructuresKHR<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBuildAccelerationStructuresKHR(api_dump, commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdBuildAccelerationStructuresIndirectKHR", "commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdBuildAccelerationStructuresIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
+    dump_function_head(api_dump, "vkCmdBuildAccelerationStructuresIndirectKHR", "commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(api_dump, commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
         }
     }
     device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdBuildAccelerationStructuresIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(api_dump, commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkBuildAccelerationStructuresKHR", "device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkBuildAccelerationStructuresKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
+    dump_function_head(api_dump, "vkBuildAccelerationStructuresKHR", "device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkBuildAccelerationStructuresKHR(api_dump, device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
         }
     }
     VkResult result = device_dispatch_table(device)->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkBuildAccelerationStructuresKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkBuildAccelerationStructuresKHR(api_dump, device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyAccelerationStructureKHR", "device, deferredOperation, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
+    dump_function_head(api_dump, "vkCopyAccelerationStructureKHR", "device, deferredOperation, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyAccelerationStructureKHR(api_dump, device, deferredOperation, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyAccelerationStructureKHR(device, deferredOperation, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyAccelerationStructureKHR(api_dump, device, deferredOperation, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyAccelerationStructureToMemoryKHR", "device, deferredOperation, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyAccelerationStructureToMemoryKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
+    dump_function_head(api_dump, "vkCopyAccelerationStructureToMemoryKHR", "device, deferredOperation, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyAccelerationStructureToMemoryKHR(api_dump, device, deferredOperation, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyAccelerationStructureToMemoryKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyAccelerationStructureToMemoryKHR(api_dump, device, deferredOperation, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToAccelerationStructureKHR", "device, deferredOperation, pInfo", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCopyMemoryToAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
+    dump_function_head(api_dump, "vkCopyMemoryToAccelerationStructureKHR", "device, deferredOperation, pInfo", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCopyMemoryToAccelerationStructureKHR(api_dump, device, deferredOperation, pInfo);
         }
     }
     VkResult result = device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCopyMemoryToAccelerationStructureKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCopyMemoryToAccelerationStructureKHR(api_dump, device, deferredOperation, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkWriteAccelerationStructuresPropertiesKHR", "device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkWriteAccelerationStructuresPropertiesKHR<Format>(ApiDumpInstance::current(), device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
+    dump_function_head(api_dump, "vkWriteAccelerationStructuresPropertiesKHR", "device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkWriteAccelerationStructuresPropertiesKHR(api_dump, device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
         }
     }
     VkResult result = device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkWriteAccelerationStructuresPropertiesKHR<Format>(ApiDumpInstance::current(), device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkWriteAccelerationStructuresPropertiesKHR(api_dump, device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyAccelerationStructureKHR", "commandBuffer, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyAccelerationStructureKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
+    dump_function_head(api_dump, "vkCmdCopyAccelerationStructureKHR", "commandBuffer, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyAccelerationStructureKHR(api_dump, commandBuffer, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyAccelerationStructureKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyAccelerationStructureKHR(api_dump, commandBuffer, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyAccelerationStructureToMemoryKHR", "commandBuffer, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyAccelerationStructureToMemoryKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
+    dump_function_head(api_dump, "vkCmdCopyAccelerationStructureToMemoryKHR", "commandBuffer, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(api_dump, commandBuffer, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyAccelerationStructureToMemoryKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(api_dump, commandBuffer, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToAccelerationStructureKHR", "commandBuffer, pInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdCopyMemoryToAccelerationStructureKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
+    dump_function_head(api_dump, "vkCmdCopyMemoryToAccelerationStructureKHR", "commandBuffer, pInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(api_dump, commandBuffer, pInfo);
         }
     }
     device_dispatch_table(commandBuffer)->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdCopyMemoryToAccelerationStructureKHR<Format>(ApiDumpInstance::current(), commandBuffer, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(api_dump, commandBuffer, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureDeviceAddressKHR", "device, pInfo", "VkDeviceAddress");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetAccelerationStructureDeviceAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
+    dump_function_head(api_dump, "vkGetAccelerationStructureDeviceAddressKHR", "device, pInfo", "VkDeviceAddress");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetAccelerationStructureDeviceAddressKHR(api_dump, device, pInfo);
         }
     }
     VkDeviceAddress result = device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR(device, pInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetAccelerationStructureDeviceAddressKHR<Format>(ApiDumpInstance::current(), device, pInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceAddress", result, dump_return_value_VkDeviceAddress);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetAccelerationStructureDeviceAddressKHR(api_dump, device, pInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdWriteAccelerationStructuresPropertiesKHR", "commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR<Format>(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
+    dump_function_head(api_dump, "vkCmdWriteAccelerationStructuresPropertiesKHR", "commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(api_dump, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
         }
     }
     device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR<Format>(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(api_dump, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetDeviceAccelerationStructureCompatibilityKHR", "device, pVersionInfo, pCompatibility", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR<Format>(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility);
+    dump_function_head(api_dump, "vkGetDeviceAccelerationStructureCompatibilityKHR", "device, pVersionInfo, pCompatibility", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(api_dump, device, pVersionInfo, pCompatibility);
         }
     }
     device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR<Format>(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(api_dump, device, pVersionInfo, pCompatibility);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureBuildSizesKHR", "device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetAccelerationStructureBuildSizesKHR<Format>(ApiDumpInstance::current(), device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
+    dump_function_head(api_dump, "vkGetAccelerationStructureBuildSizesKHR", "device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetAccelerationStructureBuildSizesKHR(api_dump, device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
         }
     }
     device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetAccelerationStructureBuildSizesKHR<Format>(ApiDumpInstance::current(), device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetAccelerationStructureBuildSizesKHR(api_dump, device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysKHR", "commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdTraceRaysKHR<Format>(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
+    dump_function_head(api_dump, "vkCmdTraceRaysKHR", "commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdTraceRaysKHR(api_dump, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
         }
     }
     device_dispatch_table(commandBuffer)->CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdTraceRaysKHR<Format>(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdTraceRaysKHR(api_dump, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCreateRayTracingPipelinesKHR", "device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCreateRayTracingPipelinesKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    dump_function_head(api_dump, "vkCreateRayTracingPipelinesKHR", "device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCreateRayTracingPipelinesKHR(api_dump, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         }
     }
     VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCreateRayTracingPipelinesKHR<Format>(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCreateRayTracingPipelinesKHR(api_dump, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR<Format>(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData);
+    dump_function_head(api_dump, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(api_dump, device, pipeline, firstGroup, groupCount, dataSize, pData);
         }
     }
     VkResult result = device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult<Format>);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR<Format>(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkResult", result, dump_return_value_VkResult);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(api_dump, device, pipeline, firstGroup, groupCount, dataSize, pData);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysIndirectKHR", "commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdTraceRaysIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
+    dump_function_head(api_dump, "vkCmdTraceRaysIndirectKHR", "commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdTraceRaysIndirectKHR(api_dump, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
         }
     }
     device_dispatch_table(commandBuffer)->CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdTraceRaysIndirectKHR<Format>(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdTraceRaysIndirectKHR(api_dump, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingShaderGroupStackSizeKHR", "device, pipeline, group, groupShader", "VkDeviceSize");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkGetRayTracingShaderGroupStackSizeKHR<Format>(ApiDumpInstance::current(), device, pipeline, group, groupShader);
+    dump_function_head(api_dump, "vkGetRayTracingShaderGroupStackSizeKHR", "device, pipeline, group, groupShader", "VkDeviceSize");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkGetRayTracingShaderGroupStackSizeKHR(api_dump, device, pipeline, group, groupShader);
         }
     }
     VkDeviceSize result = device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_return_value<Format>(ApiDumpInstance::current().settings(), "VkDeviceSize", result);
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkGetRayTracingShaderGroupStackSizeKHR<Format>(ApiDumpInstance::current(), device, pipeline, group, groupShader);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_return_value(api_dump, "VkDeviceSize", result);
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkGetRayTracingShaderGroupStackSizeKHR(api_dump, device, pipeline, group, groupShader);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
     return result;
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdSetRayTracingPipelineStackSizeKHR", "commandBuffer, pipelineStackSize", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdSetRayTracingPipelineStackSizeKHR<Format>(ApiDumpInstance::current(), commandBuffer, pipelineStackSize);
+    dump_function_head(api_dump, "vkCmdSetRayTracingPipelineStackSizeKHR", "commandBuffer, pipelineStackSize", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(api_dump, commandBuffer, pipelineStackSize);
         }
     }
     device_dispatch_table(commandBuffer)->CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdSetRayTracingPipelineStackSizeKHR<Format>(ApiDumpInstance::current(), commandBuffer, pipelineStackSize);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(api_dump, commandBuffer, pipelineStackSize);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksEXT", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMeshTasksEXT<Format>(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ);
+    dump_function_head(api_dump, "vkCmdDrawMeshTasksEXT", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMeshTasksEXT(api_dump, commandBuffer, groupCountX, groupCountY, groupCountZ);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMeshTasksEXT<Format>(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMeshTasksEXT(api_dump, commandBuffer, groupCountX, groupCountY, groupCountZ);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectEXT", "commandBuffer, buffer, offset, drawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMeshTasksIndirectEXT<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawMeshTasksIndirectEXT", "commandBuffer, buffer, offset, drawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMeshTasksIndirectEXT(api_dump, commandBuffer, buffer, offset, drawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMeshTasksIndirectEXT<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMeshTasksIndirectEXT(api_dump, commandBuffer, buffer, offset, drawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-template <ApiDumpFormat Format>
 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
-    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
+    auto& api_dump = ApiDumpInstance::current();
+    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
 
-    dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectCountEXT", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
-    if constexpr (Format == ApiDumpFormat::Text) {
-        if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {
-            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-            dump_params_vkCmdDrawMeshTasksIndirectCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    dump_function_head(api_dump, "vkCmdDrawMeshTasksIndirectCountEXT", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void");
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        if (api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {
+            dump_before_pre_dump_formatting(api_dump);
+            dump_params_vkCmdDrawMeshTasksIndirectCountEXT(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
         }
     }
     device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-    if (ApiDumpInstance::current().shouldDumpOutput()) {
-        dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-        dump_params_vkCmdDrawMeshTasksIndirectCountEXT<Format>(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-        dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-        flush(ApiDumpInstance::current().settings());
+    if (api_dump.shouldDumpOutput()) {
+        dump_pre_function_formatting(api_dump);
+        dump_params_vkCmdDrawMeshTasksIndirectCountEXT(api_dump, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+        dump_post_function_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
-
-template <ApiDumpFormat Format>
 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_instance_functions(VkInstance instance, const char* pName) {
     if (strcmp(pName, "vkCreateInstance") == 0)
         return reinterpret_cast<PFN_vkVoidFunction>(vkCreateInstance);
     if (strcmp(pName, "vkDestroyInstance") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyInstance<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyInstance);
     if (strcmp(pName, "vkEnumeratePhysicalDevices") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDevices<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDevices);
     if (strcmp(pName, "vkGetPhysicalDeviceFeatures") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures);
     if (strcmp(pName, "vkGetPhysicalDeviceFormatProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceMemoryProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties);
     if (strcmp(pName, "vkGetInstanceProcAddr") == 0)
         return reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr);
     if (strcmp(pName, "vkCreateDevice") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDevice<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDevice);
     if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0)
         return reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceExtensionProperties);
     if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0)
@@ -15377,1623 +15375,1621 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_instance_functions(VkIns
     if (strcmp(pName, "vkEnumerateDeviceLayerProperties") == 0)
         return reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceLayerProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties);
     if (strcmp(pName, "vkEnumeratePhysicalDeviceGroups") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceGroups<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceGroups);
     if (strcmp(pName, "vkGetPhysicalDeviceFeatures2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures2);
     if (strcmp(pName, "vkGetPhysicalDeviceProperties2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties2);
     if (strcmp(pName, "vkGetPhysicalDeviceFormatProperties2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties2);
     if (strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties2);
     if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties2);
     if (strcmp(pName, "vkGetPhysicalDeviceMemoryProperties2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties2);
     if (strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties2") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties2);
     if (strcmp(pName, "vkGetPhysicalDeviceExternalBufferProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalBufferProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalBufferProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceExternalFenceProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalFenceProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalFenceProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceExternalSemaphoreProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalSemaphoreProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalSemaphoreProperties);
     if (strcmp(pName, "vkGetPhysicalDeviceToolProperties") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceToolProperties<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceToolProperties);
     if (strcmp(pName, "vkDestroySurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSurfaceSupportKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSurfaceFormatsKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSurfacePresentModesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR);
     if (strcmp(pName, "vkGetPhysicalDevicePresentRectanglesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDevicePresentRectanglesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDevicePresentRectanglesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceDisplayPropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayPropertiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayPlanePropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
     if (strcmp(pName, "vkGetDisplayPlaneSupportedDisplaysKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayPlaneSupportedDisplaysKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayPlaneSupportedDisplaysKHR);
     if (strcmp(pName, "vkGetDisplayModePropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayModePropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayModePropertiesKHR);
     if (strcmp(pName, "vkCreateDisplayModeKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDisplayModeKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDisplayModeKHR);
     if (strcmp(pName, "vkGetDisplayPlaneCapabilitiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayPlaneCapabilitiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayPlaneCapabilitiesKHR);
     if (strcmp(pName, "vkCreateDisplayPlaneSurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDisplayPlaneSurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDisplayPlaneSurfaceKHR);
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
     if (strcmp(pName, "vkCreateXlibSurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateXlibSurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateXlibSurfaceKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceXlibPresentationSupportKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceXlibPresentationSupportKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceXlibPresentationSupportKHR);
 #endif  // VK_USE_PLATFORM_XLIB_KHR
 #if defined(VK_USE_PLATFORM_XCB_KHR)
     if (strcmp(pName, "vkCreateXcbSurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateXcbSurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateXcbSurfaceKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceXcbPresentationSupportKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceXcbPresentationSupportKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceXcbPresentationSupportKHR);
 #endif  // VK_USE_PLATFORM_XCB_KHR
 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
     if (strcmp(pName, "vkCreateWaylandSurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateWaylandSurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateWaylandSurfaceKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceWaylandPresentationSupportKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceWaylandPresentationSupportKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceWaylandPresentationSupportKHR);
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
     if (strcmp(pName, "vkCreateAndroidSurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateAndroidSurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateAndroidSurfaceKHR);
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkCreateWin32SurfaceKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateWin32SurfaceKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateWin32SurfaceKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceWin32PresentationSupportKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceWin32PresentationSupportKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceWin32PresentationSupportKHR);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkGetPhysicalDeviceVideoCapabilitiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceVideoCapabilitiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceVideoCapabilitiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceVideoFormatPropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceVideoFormatPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceVideoFormatPropertiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceFeatures2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceFormatProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceMemoryProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
     if (strcmp(pName, "vkEnumeratePhysicalDeviceGroupsKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceGroupsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceGroupsKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceExternalBufferPropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalBufferPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalBufferPropertiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceExternalFencePropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalFencePropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalFencePropertiesKHR);
     if (strcmp(pName, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilities2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilities2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilities2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceSurfaceFormats2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormats2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormats2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceDisplayProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayProperties2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayPlaneProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDisplayPlaneProperties2KHR);
     if (strcmp(pName, "vkGetDisplayModeProperties2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayModeProperties2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayModeProperties2KHR);
     if (strcmp(pName, "vkGetDisplayPlaneCapabilities2KHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayPlaneCapabilities2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDisplayPlaneCapabilities2KHR);
     if (strcmp(pName, "vkGetPhysicalDeviceFragmentShadingRatesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFragmentShadingRatesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFragmentShadingRatesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR);
     if (strcmp(pName, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR);
     if (strcmp(pName, "vkCreateDebugReportCallbackEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDebugReportCallbackEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDebugReportCallbackEXT);
     if (strcmp(pName, "vkDestroyDebugReportCallbackEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDebugReportCallbackEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDebugReportCallbackEXT);
     if (strcmp(pName, "vkDebugReportMessageEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDebugReportMessageEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDebugReportMessageEXT);
 #if defined(VK_USE_PLATFORM_GGP)
     if (strcmp(pName, "vkCreateStreamDescriptorSurfaceGGP") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateStreamDescriptorSurfaceGGP<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateStreamDescriptorSurfaceGGP);
 #endif  // VK_USE_PLATFORM_GGP
     if (strcmp(pName, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalImageFormatPropertiesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalImageFormatPropertiesNV);
 #if defined(VK_USE_PLATFORM_VI_NN)
     if (strcmp(pName, "vkCreateViSurfaceNN") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateViSurfaceNN<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateViSurfaceNN);
 #endif  // VK_USE_PLATFORM_VI_NN
     if (strcmp(pName, "vkReleaseDisplayEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseDisplayEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseDisplayEXT);
 #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
     if (strcmp(pName, "vkAcquireXlibDisplayEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireXlibDisplayEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireXlibDisplayEXT);
     if (strcmp(pName, "vkGetRandROutputDisplayEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRandROutputDisplayEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRandROutputDisplayEXT);
 #endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT
     if (strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilities2EXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilities2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilities2EXT);
 #if defined(VK_USE_PLATFORM_IOS_MVK)
     if (strcmp(pName, "vkCreateIOSSurfaceMVK") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIOSSurfaceMVK<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIOSSurfaceMVK);
 #endif  // VK_USE_PLATFORM_IOS_MVK
 #if defined(VK_USE_PLATFORM_MACOS_MVK)
     if (strcmp(pName, "vkCreateMacOSSurfaceMVK") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMacOSSurfaceMVK<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMacOSSurfaceMVK);
 #endif  // VK_USE_PLATFORM_MACOS_MVK
     if (strcmp(pName, "vkSetDebugUtilsObjectNameEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectNameEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectNameEXT);
     if (strcmp(pName, "vkSetDebugUtilsObjectTagEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectTagEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectTagEXT);
     if (strcmp(pName, "vkQueueBeginDebugUtilsLabelEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueBeginDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueBeginDebugUtilsLabelEXT);
     if (strcmp(pName, "vkQueueEndDebugUtilsLabelEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueEndDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueEndDebugUtilsLabelEXT);
     if (strcmp(pName, "vkQueueInsertDebugUtilsLabelEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueInsertDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueInsertDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCmdBeginDebugUtilsLabelEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCmdEndDebugUtilsLabelEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCmdInsertDebugUtilsLabelEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdInsertDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdInsertDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCreateDebugUtilsMessengerEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDebugUtilsMessengerEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDebugUtilsMessengerEXT);
     if (strcmp(pName, "vkDestroyDebugUtilsMessengerEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDebugUtilsMessengerEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDebugUtilsMessengerEXT);
     if (strcmp(pName, "vkSubmitDebugUtilsMessageEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSubmitDebugUtilsMessageEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSubmitDebugUtilsMessageEXT);
     if (strcmp(pName, "vkGetPhysicalDeviceDescriptorSizeEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDescriptorSizeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDescriptorSizeEXT);
     if (strcmp(pName, "vkGetPhysicalDeviceMultisamplePropertiesEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMultisamplePropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMultisamplePropertiesEXT);
     if (strcmp(pName, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT);
 #if defined(VK_USE_PLATFORM_FUCHSIA)
     if (strcmp(pName, "vkCreateImagePipeSurfaceFUCHSIA") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateImagePipeSurfaceFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateImagePipeSurfaceFUCHSIA);
 #endif  // VK_USE_PLATFORM_FUCHSIA
 #if defined(VK_USE_PLATFORM_METAL_EXT)
     if (strcmp(pName, "vkCreateMetalSurfaceEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMetalSurfaceEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMetalSurfaceEXT);
 #endif  // VK_USE_PLATFORM_METAL_EXT
     if (strcmp(pName, "vkGetPhysicalDeviceToolPropertiesEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceToolPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceToolPropertiesEXT);
     if (strcmp(pName, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV);
     if (strcmp(pName, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkGetPhysicalDeviceSurfacePresentModes2EXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModes2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModes2EXT);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkCreateHeadlessSurfaceEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateHeadlessSurfaceEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateHeadlessSurfaceEXT);
     if (strcmp(pName, "vkAcquireDrmDisplayEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireDrmDisplayEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireDrmDisplayEXT);
     if (strcmp(pName, "vkGetDrmDisplayEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDrmDisplayEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDrmDisplayEXT);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkAcquireWinrtDisplayNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireWinrtDisplayNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireWinrtDisplayNV);
     if (strcmp(pName, "vkGetWinrtDisplayNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetWinrtDisplayNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetWinrtDisplayNV);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
     if (strcmp(pName, "vkCreateDirectFBSurfaceEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDirectFBSurfaceEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDirectFBSurfaceEXT);
     if (strcmp(pName, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDirectFBPresentationSupportEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceDirectFBPresentationSupportEXT);
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
     if (strcmp(pName, "vkCreateScreenSurfaceQNX") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateScreenSurfaceQNX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateScreenSurfaceQNX);
     if (strcmp(pName, "vkGetPhysicalDeviceScreenPresentationSupportQNX") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceScreenPresentationSupportQNX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceScreenPresentationSupportQNX);
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     if (strcmp(pName, "vkGetPhysicalDeviceExternalTensorPropertiesARM") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalTensorPropertiesARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceExternalTensorPropertiesARM);
     if (strcmp(pName, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceOpticalFlowImageFormatsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceOpticalFlowImageFormatsNV);
     if (strcmp(pName, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeVectorPropertiesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeVectorPropertiesNV);
     if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM);
     if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM);
 #if defined(VK_USE_PLATFORM_OHOS)
     if (strcmp(pName, "vkCreateSurfaceOHOS") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSurfaceOHOS<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSurfaceOHOS);
 #endif  // VK_USE_PLATFORM_OHOS
     if (strcmp(pName, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV);
     if (strcmp(pName, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM);
 
     return nullptr;
 }
-
-template <ApiDumpFormat Format>
 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_device_functions(VkDevice device, const char* pName) {
     if (strcmp(pName, "vkGetDeviceProcAddr") == 0 && (!device || device_dispatch_table(device)->GetDeviceProcAddr))
         return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr);
     if (strcmp(pName, "vkDestroyDevice") == 0 && (!device || device_dispatch_table(device)->DestroyDevice))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDevice<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDevice);
     if (strcmp(pName, "vkGetDeviceQueue") == 0 && (!device || device_dispatch_table(device)->GetDeviceQueue))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue);
     if (strcmp(pName, "vkQueueSubmit") == 0 && (!device || device_dispatch_table(device)->QueueSubmit))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit);
     if (strcmp(pName, "vkQueueWaitIdle") == 0 && (!device || device_dispatch_table(device)->QueueWaitIdle))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle);
     if (strcmp(pName, "vkDeviceWaitIdle") == 0 && (!device || device_dispatch_table(device)->DeviceWaitIdle))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle);
     if (strcmp(pName, "vkAllocateMemory") == 0 && (!device || device_dispatch_table(device)->AllocateMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory);
     if (strcmp(pName, "vkFreeMemory") == 0 && (!device || device_dispatch_table(device)->FreeMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory);
     if (strcmp(pName, "vkMapMemory") == 0 && (!device || device_dispatch_table(device)->MapMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory);
     if (strcmp(pName, "vkUnmapMemory") == 0 && (!device || device_dispatch_table(device)->UnmapMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory);
     if (strcmp(pName, "vkFlushMappedMemoryRanges") == 0 && (!device || device_dispatch_table(device)->FlushMappedMemoryRanges))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges);
     if (strcmp(pName, "vkInvalidateMappedMemoryRanges") == 0 && (!device || device_dispatch_table(device)->InvalidateMappedMemoryRanges))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges);
     if (strcmp(pName, "vkGetDeviceMemoryCommitment") == 0 && (!device || device_dispatch_table(device)->GetDeviceMemoryCommitment))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment);
     if (strcmp(pName, "vkBindBufferMemory") == 0 && (!device || device_dispatch_table(device)->BindBufferMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory);
     if (strcmp(pName, "vkBindImageMemory") == 0 && (!device || device_dispatch_table(device)->BindImageMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory);
     if (strcmp(pName, "vkGetBufferMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetBufferMemoryRequirements))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements);
     if (strcmp(pName, "vkGetImageMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetImageMemoryRequirements))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements);
     if (strcmp(pName, "vkGetImageSparseMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetImageSparseMemoryRequirements))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements);
     if (strcmp(pName, "vkQueueBindSparse") == 0 && (!device || device_dispatch_table(device)->QueueBindSparse))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse);
     if (strcmp(pName, "vkCreateFence") == 0 && (!device || device_dispatch_table(device)->CreateFence))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence);
     if (strcmp(pName, "vkDestroyFence") == 0 && (!device || device_dispatch_table(device)->DestroyFence))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence);
     if (strcmp(pName, "vkResetFences") == 0 && (!device || device_dispatch_table(device)->ResetFences))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetFences<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetFences);
     if (strcmp(pName, "vkGetFenceStatus") == 0 && (!device || device_dispatch_table(device)->GetFenceStatus))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus);
     if (strcmp(pName, "vkWaitForFences") == 0 && (!device || device_dispatch_table(device)->WaitForFences))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences);
     if (strcmp(pName, "vkCreateSemaphore") == 0 && (!device || device_dispatch_table(device)->CreateSemaphore))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore);
     if (strcmp(pName, "vkDestroySemaphore") == 0 && (!device || device_dispatch_table(device)->DestroySemaphore))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore);
     if (strcmp(pName, "vkCreateQueryPool") == 0 && (!device || device_dispatch_table(device)->CreateQueryPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool);
     if (strcmp(pName, "vkDestroyQueryPool") == 0 && (!device || device_dispatch_table(device)->DestroyQueryPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool);
     if (strcmp(pName, "vkGetQueryPoolResults") == 0 && (!device || device_dispatch_table(device)->GetQueryPoolResults))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults);
     if (strcmp(pName, "vkCreateBuffer") == 0 && (!device || device_dispatch_table(device)->CreateBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer);
     if (strcmp(pName, "vkDestroyBuffer") == 0 && (!device || device_dispatch_table(device)->DestroyBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer);
     if (strcmp(pName, "vkCreateImage") == 0 && (!device || device_dispatch_table(device)->CreateImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage);
     if (strcmp(pName, "vkDestroyImage") == 0 && (!device || device_dispatch_table(device)->DestroyImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage);
     if (strcmp(pName, "vkGetImageSubresourceLayout") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout);
     if (strcmp(pName, "vkCreateImageView") == 0 && (!device || device_dispatch_table(device)->CreateImageView))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView);
     if (strcmp(pName, "vkDestroyImageView") == 0 && (!device || device_dispatch_table(device)->DestroyImageView))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView);
     if (strcmp(pName, "vkCreateCommandPool") == 0 && (!device || device_dispatch_table(device)->CreateCommandPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool);
     if (strcmp(pName, "vkDestroyCommandPool") == 0 && (!device || device_dispatch_table(device)->DestroyCommandPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool);
     if (strcmp(pName, "vkResetCommandPool") == 0 && (!device || device_dispatch_table(device)->ResetCommandPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool);
     if (strcmp(pName, "vkAllocateCommandBuffers") == 0 && (!device || device_dispatch_table(device)->AllocateCommandBuffers))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers);
     if (strcmp(pName, "vkFreeCommandBuffers") == 0 && (!device || device_dispatch_table(device)->FreeCommandBuffers))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers);
     if (strcmp(pName, "vkBeginCommandBuffer") == 0 && (!device || device_dispatch_table(device)->BeginCommandBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer);
     if (strcmp(pName, "vkEndCommandBuffer") == 0 && (!device || device_dispatch_table(device)->EndCommandBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer);
     if (strcmp(pName, "vkResetCommandBuffer") == 0 && (!device || device_dispatch_table(device)->ResetCommandBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer);
     if (strcmp(pName, "vkCmdCopyBuffer") == 0 && (!device || device_dispatch_table(device)->CmdCopyBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer);
     if (strcmp(pName, "vkCmdCopyImage") == 0 && (!device || device_dispatch_table(device)->CmdCopyImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage);
     if (strcmp(pName, "vkCmdCopyBufferToImage") == 0 && (!device || device_dispatch_table(device)->CmdCopyBufferToImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage);
     if (strcmp(pName, "vkCmdCopyImageToBuffer") == 0 && (!device || device_dispatch_table(device)->CmdCopyImageToBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer);
     if (strcmp(pName, "vkCmdUpdateBuffer") == 0 && (!device || device_dispatch_table(device)->CmdUpdateBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer);
     if (strcmp(pName, "vkCmdFillBuffer") == 0 && (!device || device_dispatch_table(device)->CmdFillBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer);
     if (strcmp(pName, "vkCmdPipelineBarrier") == 0 && (!device || device_dispatch_table(device)->CmdPipelineBarrier))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier);
     if (strcmp(pName, "vkCmdBeginQuery") == 0 && (!device || device_dispatch_table(device)->CmdBeginQuery))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery);
     if (strcmp(pName, "vkCmdEndQuery") == 0 && (!device || device_dispatch_table(device)->CmdEndQuery))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery);
     if (strcmp(pName, "vkCmdResetQueryPool") == 0 && (!device || device_dispatch_table(device)->CmdResetQueryPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool);
     if (strcmp(pName, "vkCmdWriteTimestamp") == 0 && (!device || device_dispatch_table(device)->CmdWriteTimestamp))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp);
     if (strcmp(pName, "vkCmdCopyQueryPoolResults") == 0 && (!device || device_dispatch_table(device)->CmdCopyQueryPoolResults))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults);
     if (strcmp(pName, "vkCmdExecuteCommands") == 0 && (!device || device_dispatch_table(device)->CmdExecuteCommands))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands);
     if (strcmp(pName, "vkCreateEvent") == 0 && (!device || device_dispatch_table(device)->CreateEvent))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent);
     if (strcmp(pName, "vkDestroyEvent") == 0 && (!device || device_dispatch_table(device)->DestroyEvent))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent);
     if (strcmp(pName, "vkGetEventStatus") == 0 && (!device || device_dispatch_table(device)->GetEventStatus))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus);
     if (strcmp(pName, "vkSetEvent") == 0 && (!device || device_dispatch_table(device)->SetEvent))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent);
     if (strcmp(pName, "vkResetEvent") == 0 && (!device || device_dispatch_table(device)->ResetEvent))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent);
     if (strcmp(pName, "vkCreateBufferView") == 0 && (!device || device_dispatch_table(device)->CreateBufferView))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView);
     if (strcmp(pName, "vkDestroyBufferView") == 0 && (!device || device_dispatch_table(device)->DestroyBufferView))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView);
     if (strcmp(pName, "vkCreateShaderModule") == 0 && (!device || device_dispatch_table(device)->CreateShaderModule))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule);
     if (strcmp(pName, "vkDestroyShaderModule") == 0 && (!device || device_dispatch_table(device)->DestroyShaderModule))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule);
     if (strcmp(pName, "vkCreatePipelineCache") == 0 && (!device || device_dispatch_table(device)->CreatePipelineCache))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache);
     if (strcmp(pName, "vkDestroyPipelineCache") == 0 && (!device || device_dispatch_table(device)->DestroyPipelineCache))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache);
     if (strcmp(pName, "vkGetPipelineCacheData") == 0 && (!device || device_dispatch_table(device)->GetPipelineCacheData))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData);
     if (strcmp(pName, "vkMergePipelineCaches") == 0 && (!device || device_dispatch_table(device)->MergePipelineCaches))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches);
     if (strcmp(pName, "vkCreateComputePipelines") == 0 && (!device || device_dispatch_table(device)->CreateComputePipelines))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines);
     if (strcmp(pName, "vkDestroyPipeline") == 0 && (!device || device_dispatch_table(device)->DestroyPipeline))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline);
     if (strcmp(pName, "vkCreatePipelineLayout") == 0 && (!device || device_dispatch_table(device)->CreatePipelineLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout);
     if (strcmp(pName, "vkDestroyPipelineLayout") == 0 && (!device || device_dispatch_table(device)->DestroyPipelineLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout);
     if (strcmp(pName, "vkCreateSampler") == 0 && (!device || device_dispatch_table(device)->CreateSampler))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler);
     if (strcmp(pName, "vkDestroySampler") == 0 && (!device || device_dispatch_table(device)->DestroySampler))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler);
     if (strcmp(pName, "vkCreateDescriptorSetLayout") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorSetLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout);
     if (strcmp(pName, "vkDestroyDescriptorSetLayout") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorSetLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout);
     if (strcmp(pName, "vkCreateDescriptorPool") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool);
     if (strcmp(pName, "vkDestroyDescriptorPool") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool);
     if (strcmp(pName, "vkResetDescriptorPool") == 0 && (!device || device_dispatch_table(device)->ResetDescriptorPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool);
     if (strcmp(pName, "vkAllocateDescriptorSets") == 0 && (!device || device_dispatch_table(device)->AllocateDescriptorSets))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets);
     if (strcmp(pName, "vkFreeDescriptorSets") == 0 && (!device || device_dispatch_table(device)->FreeDescriptorSets))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets);
     if (strcmp(pName, "vkUpdateDescriptorSets") == 0 && (!device || device_dispatch_table(device)->UpdateDescriptorSets))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets);
     if (strcmp(pName, "vkCmdBindPipeline") == 0 && (!device || device_dispatch_table(device)->CmdBindPipeline))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline);
     if (strcmp(pName, "vkCmdBindDescriptorSets") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorSets))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets);
     if (strcmp(pName, "vkCmdClearColorImage") == 0 && (!device || device_dispatch_table(device)->CmdClearColorImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage);
     if (strcmp(pName, "vkCmdDispatch") == 0 && (!device || device_dispatch_table(device)->CmdDispatch))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch);
     if (strcmp(pName, "vkCmdDispatchIndirect") == 0 && (!device || device_dispatch_table(device)->CmdDispatchIndirect))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect);
     if (strcmp(pName, "vkCmdSetEvent") == 0 && (!device || device_dispatch_table(device)->CmdSetEvent))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent);
     if (strcmp(pName, "vkCmdResetEvent") == 0 && (!device || device_dispatch_table(device)->CmdResetEvent))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent);
     if (strcmp(pName, "vkCmdWaitEvents") == 0 && (!device || device_dispatch_table(device)->CmdWaitEvents))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents);
     if (strcmp(pName, "vkCmdPushConstants") == 0 && (!device || device_dispatch_table(device)->CmdPushConstants))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants);
     if (strcmp(pName, "vkCreateGraphicsPipelines") == 0 && (!device || device_dispatch_table(device)->CreateGraphicsPipelines))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines);
     if (strcmp(pName, "vkCreateFramebuffer") == 0 && (!device || device_dispatch_table(device)->CreateFramebuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer);
     if (strcmp(pName, "vkDestroyFramebuffer") == 0 && (!device || device_dispatch_table(device)->DestroyFramebuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer);
     if (strcmp(pName, "vkCreateRenderPass") == 0 && (!device || device_dispatch_table(device)->CreateRenderPass))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass);
     if (strcmp(pName, "vkDestroyRenderPass") == 0 && (!device || device_dispatch_table(device)->DestroyRenderPass))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass);
     if (strcmp(pName, "vkGetRenderAreaGranularity") == 0 && (!device || device_dispatch_table(device)->GetRenderAreaGranularity))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity);
     if (strcmp(pName, "vkCmdSetViewport") == 0 && (!device || device_dispatch_table(device)->CmdSetViewport))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport);
     if (strcmp(pName, "vkCmdSetScissor") == 0 && (!device || device_dispatch_table(device)->CmdSetScissor))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor);
     if (strcmp(pName, "vkCmdSetLineWidth") == 0 && (!device || device_dispatch_table(device)->CmdSetLineWidth))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth);
     if (strcmp(pName, "vkCmdSetDepthBias") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBias))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias);
     if (strcmp(pName, "vkCmdSetBlendConstants") == 0 && (!device || device_dispatch_table(device)->CmdSetBlendConstants))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants);
     if (strcmp(pName, "vkCmdSetDepthBounds") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBounds))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds);
     if (strcmp(pName, "vkCmdSetStencilCompareMask") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilCompareMask))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask);
     if (strcmp(pName, "vkCmdSetStencilWriteMask") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilWriteMask))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask);
     if (strcmp(pName, "vkCmdSetStencilReference") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilReference))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference);
     if (strcmp(pName, "vkCmdBindIndexBuffer") == 0 && (!device || device_dispatch_table(device)->CmdBindIndexBuffer))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer);
     if (strcmp(pName, "vkCmdBindVertexBuffers") == 0 && (!device || device_dispatch_table(device)->CmdBindVertexBuffers))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers);
     if (strcmp(pName, "vkCmdDraw") == 0 && (!device || device_dispatch_table(device)->CmdDraw))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw);
     if (strcmp(pName, "vkCmdDrawIndexed") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexed))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed);
     if (strcmp(pName, "vkCmdDrawIndirect") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirect))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect);
     if (strcmp(pName, "vkCmdDrawIndexedIndirect") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirect))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect);
     if (strcmp(pName, "vkCmdBlitImage") == 0 && (!device || device_dispatch_table(device)->CmdBlitImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage);
     if (strcmp(pName, "vkCmdClearDepthStencilImage") == 0 && (!device || device_dispatch_table(device)->CmdClearDepthStencilImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage);
     if (strcmp(pName, "vkCmdClearAttachments") == 0 && (!device || device_dispatch_table(device)->CmdClearAttachments))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments);
     if (strcmp(pName, "vkCmdResolveImage") == 0 && (!device || device_dispatch_table(device)->CmdResolveImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage);
     if (strcmp(pName, "vkCmdBeginRenderPass") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderPass))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass);
     if (strcmp(pName, "vkCmdNextSubpass") == 0 && (!device || device_dispatch_table(device)->CmdNextSubpass))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass);
     if (strcmp(pName, "vkCmdEndRenderPass") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderPass))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass);
     if (strcmp(pName, "vkBindBufferMemory2") == 0 && (!device || device_dispatch_table(device)->BindBufferMemory2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory2);
     if (strcmp(pName, "vkBindImageMemory2") == 0 && (!device || device_dispatch_table(device)->BindImageMemory2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory2);
     if (strcmp(pName, "vkGetDeviceGroupPeerMemoryFeatures") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupPeerMemoryFeatures<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupPeerMemoryFeatures);
     if (strcmp(pName, "vkCmdSetDeviceMask") == 0 && (!device || device_dispatch_table(device)->CmdSetDeviceMask))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDeviceMask<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDeviceMask);
     if (strcmp(pName, "vkGetImageMemoryRequirements2") == 0 && (!device || device_dispatch_table(device)->GetImageMemoryRequirements2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements2);
     if (strcmp(pName, "vkGetBufferMemoryRequirements2") == 0 && (!device || device_dispatch_table(device)->GetBufferMemoryRequirements2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements2);
     if (strcmp(pName, "vkGetImageSparseMemoryRequirements2") == 0 && (!device || device_dispatch_table(device)->GetImageSparseMemoryRequirements2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements2);
     if (strcmp(pName, "vkTrimCommandPool") == 0 && (!device || device_dispatch_table(device)->TrimCommandPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkTrimCommandPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkTrimCommandPool);
     if (strcmp(pName, "vkGetDeviceQueue2") == 0 && (!device || device_dispatch_table(device)->GetDeviceQueue2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue2);
     if (strcmp(pName, "vkCmdDispatchBase") == 0 && (!device || device_dispatch_table(device)->CmdDispatchBase))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchBase<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchBase);
     if (strcmp(pName, "vkCreateDescriptorUpdateTemplate") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorUpdateTemplate))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorUpdateTemplate<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorUpdateTemplate);
     if (strcmp(pName, "vkDestroyDescriptorUpdateTemplate") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorUpdateTemplate))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorUpdateTemplate<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorUpdateTemplate);
     if (strcmp(pName, "vkUpdateDescriptorSetWithTemplate") == 0 && (!device || device_dispatch_table(device)->UpdateDescriptorSetWithTemplate))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSetWithTemplate<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSetWithTemplate);
     if (strcmp(pName, "vkGetDescriptorSetLayoutSupport") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutSupport))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutSupport<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutSupport);
     if (strcmp(pName, "vkCreateSamplerYcbcrConversion") == 0 && (!device || device_dispatch_table(device)->CreateSamplerYcbcrConversion))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSamplerYcbcrConversion<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSamplerYcbcrConversion);
     if (strcmp(pName, "vkDestroySamplerYcbcrConversion") == 0 && (!device || device_dispatch_table(device)->DestroySamplerYcbcrConversion))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySamplerYcbcrConversion<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySamplerYcbcrConversion);
     if (strcmp(pName, "vkResetQueryPool") == 0 && (!device || device_dispatch_table(device)->ResetQueryPool))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetQueryPool<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetQueryPool);
     if (strcmp(pName, "vkGetSemaphoreCounterValue") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreCounterValue))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreCounterValue<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreCounterValue);
     if (strcmp(pName, "vkWaitSemaphores") == 0 && (!device || device_dispatch_table(device)->WaitSemaphores))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitSemaphores<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitSemaphores);
     if (strcmp(pName, "vkSignalSemaphore") == 0 && (!device || device_dispatch_table(device)->SignalSemaphore))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSignalSemaphore<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSignalSemaphore);
     if (strcmp(pName, "vkGetBufferDeviceAddress") == 0 && (!device || device_dispatch_table(device)->GetBufferDeviceAddress))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferDeviceAddress<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferDeviceAddress);
     if (strcmp(pName, "vkGetBufferOpaqueCaptureAddress") == 0 && (!device || device_dispatch_table(device)->GetBufferOpaqueCaptureAddress))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferOpaqueCaptureAddress<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferOpaqueCaptureAddress);
     if (strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddress") == 0 && (!device || device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryOpaqueCaptureAddress<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryOpaqueCaptureAddress);
     if (strcmp(pName, "vkCmdDrawIndirectCount") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectCount))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectCount<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectCount);
     if (strcmp(pName, "vkCmdDrawIndexedIndirectCount") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirectCount))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirectCount<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirectCount);
     if (strcmp(pName, "vkCreateRenderPass2") == 0 && (!device || device_dispatch_table(device)->CreateRenderPass2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass2);
     if (strcmp(pName, "vkCmdBeginRenderPass2") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderPass2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass2);
     if (strcmp(pName, "vkCmdNextSubpass2") == 0 && (!device || device_dispatch_table(device)->CmdNextSubpass2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass2);
     if (strcmp(pName, "vkCmdEndRenderPass2") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderPass2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass2);
     if (strcmp(pName, "vkCreatePrivateDataSlot") == 0 && (!device || device_dispatch_table(device)->CreatePrivateDataSlot))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePrivateDataSlot<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePrivateDataSlot);
     if (strcmp(pName, "vkDestroyPrivateDataSlot") == 0 && (!device || device_dispatch_table(device)->DestroyPrivateDataSlot))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPrivateDataSlot<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPrivateDataSlot);
     if (strcmp(pName, "vkSetPrivateData") == 0 && (!device || device_dispatch_table(device)->SetPrivateData))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetPrivateData<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetPrivateData);
     if (strcmp(pName, "vkGetPrivateData") == 0 && (!device || device_dispatch_table(device)->GetPrivateData))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPrivateData<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPrivateData);
     if (strcmp(pName, "vkCmdPipelineBarrier2") == 0 && (!device || device_dispatch_table(device)->CmdPipelineBarrier2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier2);
     if (strcmp(pName, "vkCmdWriteTimestamp2") == 0 && (!device || device_dispatch_table(device)->CmdWriteTimestamp2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp2);
     if (strcmp(pName, "vkQueueSubmit2") == 0 && (!device || device_dispatch_table(device)->QueueSubmit2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit2);
     if (strcmp(pName, "vkCmdCopyBuffer2") == 0 && (!device || device_dispatch_table(device)->CmdCopyBuffer2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer2);
     if (strcmp(pName, "vkCmdCopyImage2") == 0 && (!device || device_dispatch_table(device)->CmdCopyImage2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage2);
     if (strcmp(pName, "vkCmdCopyBufferToImage2") == 0 && (!device || device_dispatch_table(device)->CmdCopyBufferToImage2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage2);
     if (strcmp(pName, "vkCmdCopyImageToBuffer2") == 0 && (!device || device_dispatch_table(device)->CmdCopyImageToBuffer2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer2);
     if (strcmp(pName, "vkGetDeviceBufferMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetDeviceBufferMemoryRequirements))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceBufferMemoryRequirements<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceBufferMemoryRequirements);
     if (strcmp(pName, "vkGetDeviceImageMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageMemoryRequirements))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageMemoryRequirements<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageMemoryRequirements);
     if (strcmp(pName, "vkGetDeviceImageSparseMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSparseMemoryRequirements<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSparseMemoryRequirements);
     if (strcmp(pName, "vkCmdSetEvent2") == 0 && (!device || device_dispatch_table(device)->CmdSetEvent2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent2);
     if (strcmp(pName, "vkCmdResetEvent2") == 0 && (!device || device_dispatch_table(device)->CmdResetEvent2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent2);
     if (strcmp(pName, "vkCmdWaitEvents2") == 0 && (!device || device_dispatch_table(device)->CmdWaitEvents2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents2);
     if (strcmp(pName, "vkCmdBlitImage2") == 0 && (!device || device_dispatch_table(device)->CmdBlitImage2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage2);
     if (strcmp(pName, "vkCmdResolveImage2") == 0 && (!device || device_dispatch_table(device)->CmdResolveImage2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage2);
     if (strcmp(pName, "vkCmdBeginRendering") == 0 && (!device || device_dispatch_table(device)->CmdBeginRendering))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRendering<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRendering);
     if (strcmp(pName, "vkCmdEndRendering") == 0 && (!device || device_dispatch_table(device)->CmdEndRendering))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRendering<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRendering);
     if (strcmp(pName, "vkCmdSetCullMode") == 0 && (!device || device_dispatch_table(device)->CmdSetCullMode))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCullMode<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCullMode);
     if (strcmp(pName, "vkCmdSetFrontFace") == 0 && (!device || device_dispatch_table(device)->CmdSetFrontFace))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFrontFace<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFrontFace);
     if (strcmp(pName, "vkCmdSetPrimitiveTopology") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveTopology))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveTopology<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveTopology);
     if (strcmp(pName, "vkCmdSetViewportWithCount") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWithCount))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWithCount<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWithCount);
     if (strcmp(pName, "vkCmdSetScissorWithCount") == 0 && (!device || device_dispatch_table(device)->CmdSetScissorWithCount))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissorWithCount<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissorWithCount);
     if (strcmp(pName, "vkCmdBindVertexBuffers2") == 0 && (!device || device_dispatch_table(device)->CmdBindVertexBuffers2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers2);
     if (strcmp(pName, "vkCmdSetDepthTestEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthTestEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthTestEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthTestEnable);
     if (strcmp(pName, "vkCmdSetDepthWriteEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthWriteEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthWriteEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthWriteEnable);
     if (strcmp(pName, "vkCmdSetDepthCompareOp") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthCompareOp))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthCompareOp<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthCompareOp);
     if (strcmp(pName, "vkCmdSetDepthBoundsTestEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBoundsTestEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBoundsTestEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBoundsTestEnable);
     if (strcmp(pName, "vkCmdSetStencilTestEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilTestEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilTestEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilTestEnable);
     if (strcmp(pName, "vkCmdSetStencilOp") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilOp))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilOp<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilOp);
     if (strcmp(pName, "vkCmdSetRasterizerDiscardEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizerDiscardEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizerDiscardEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizerDiscardEnable);
     if (strcmp(pName, "vkCmdSetDepthBiasEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBiasEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBiasEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBiasEnable);
     if (strcmp(pName, "vkCmdSetPrimitiveRestartEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveRestartEnable))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveRestartEnable<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveRestartEnable);
     if (strcmp(pName, "vkMapMemory2") == 0 && (!device || device_dispatch_table(device)->MapMemory2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory2);
     if (strcmp(pName, "vkUnmapMemory2") == 0 && (!device || device_dispatch_table(device)->UnmapMemory2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory2);
     if (strcmp(pName, "vkGetDeviceImageSubresourceLayout") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSubresourceLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSubresourceLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSubresourceLayout);
     if (strcmp(pName, "vkGetImageSubresourceLayout2") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout2);
     if (strcmp(pName, "vkCopyMemoryToImage") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToImage);
     if (strcmp(pName, "vkCopyImageToMemory") == 0 && (!device || device_dispatch_table(device)->CopyImageToMemory))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToMemory<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToMemory);
     if (strcmp(pName, "vkCopyImageToImage") == 0 && (!device || device_dispatch_table(device)->CopyImageToImage))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToImage<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToImage);
     if (strcmp(pName, "vkTransitionImageLayout") == 0 && (!device || device_dispatch_table(device)->TransitionImageLayout))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkTransitionImageLayout<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkTransitionImageLayout);
     if (strcmp(pName, "vkCmdPushDescriptorSet") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSet))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSet<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSet);
     if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplate") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplate))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplate<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplate);
     if (strcmp(pName, "vkCmdBindDescriptorSets2") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorSets2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets2);
     if (strcmp(pName, "vkCmdPushConstants2") == 0 && (!device || device_dispatch_table(device)->CmdPushConstants2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants2);
     if (strcmp(pName, "vkCmdPushDescriptorSet2") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSet2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSet2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSet2);
     if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplate2") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplate2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplate2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplate2);
     if (strcmp(pName, "vkCmdSetLineStipple") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStipple))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStipple<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStipple);
     if (strcmp(pName, "vkCmdBindIndexBuffer2") == 0 && (!device || device_dispatch_table(device)->CmdBindIndexBuffer2))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer2<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer2);
     if (strcmp(pName, "vkGetRenderingAreaGranularity") == 0 && (!device || device_dispatch_table(device)->GetRenderingAreaGranularity))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderingAreaGranularity<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderingAreaGranularity);
     if (strcmp(pName, "vkCmdSetRenderingAttachmentLocations") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingAttachmentLocations))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingAttachmentLocations<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingAttachmentLocations);
     if (strcmp(pName, "vkCmdSetRenderingInputAttachmentIndices") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingInputAttachmentIndices))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingInputAttachmentIndices<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingInputAttachmentIndices);
     if (strcmp(pName, "vkCreateSwapchainKHR") == 0 && (!device || device_dispatch_table(device)->CreateSwapchainKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR);
     if (strcmp(pName, "vkDestroySwapchainKHR") == 0 && (!device || device_dispatch_table(device)->DestroySwapchainKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR);
     if (strcmp(pName, "vkGetSwapchainImagesKHR") == 0 && (!device || device_dispatch_table(device)->GetSwapchainImagesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR);
     if (strcmp(pName, "vkAcquireNextImageKHR") == 0 && (!device || device_dispatch_table(device)->AcquireNextImageKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR);
     if (strcmp(pName, "vkQueuePresentKHR") == 0 && (!device || device_dispatch_table(device)->QueuePresentKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR);
     if (strcmp(pName, "vkGetDeviceGroupPresentCapabilitiesKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupPresentCapabilitiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupPresentCapabilitiesKHR);
     if (strcmp(pName, "vkGetDeviceGroupSurfacePresentModesKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupSurfacePresentModesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupSurfacePresentModesKHR);
     if (strcmp(pName, "vkAcquireNextImage2KHR") == 0 && (!device || device_dispatch_table(device)->AcquireNextImage2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImage2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImage2KHR);
     if (strcmp(pName, "vkCreateSharedSwapchainsKHR") == 0 && (!device || device_dispatch_table(device)->CreateSharedSwapchainsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSharedSwapchainsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSharedSwapchainsKHR);
     if (strcmp(pName, "vkCreateVideoSessionKHR") == 0 && (!device || device_dispatch_table(device)->CreateVideoSessionKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateVideoSessionKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateVideoSessionKHR);
     if (strcmp(pName, "vkDestroyVideoSessionKHR") == 0 && (!device || device_dispatch_table(device)->DestroyVideoSessionKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyVideoSessionKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyVideoSessionKHR);
     if (strcmp(pName, "vkGetVideoSessionMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetVideoSessionMemoryRequirementsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetVideoSessionMemoryRequirementsKHR);
     if (strcmp(pName, "vkBindVideoSessionMemoryKHR") == 0 && (!device || device_dispatch_table(device)->BindVideoSessionMemoryKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindVideoSessionMemoryKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindVideoSessionMemoryKHR);
     if (strcmp(pName, "vkCreateVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->CreateVideoSessionParametersKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateVideoSessionParametersKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateVideoSessionParametersKHR);
     if (strcmp(pName, "vkUpdateVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->UpdateVideoSessionParametersKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateVideoSessionParametersKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateVideoSessionParametersKHR);
     if (strcmp(pName, "vkDestroyVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->DestroyVideoSessionParametersKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyVideoSessionParametersKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyVideoSessionParametersKHR);
     if (strcmp(pName, "vkCmdBeginVideoCodingKHR") == 0 && (!device || device_dispatch_table(device)->CmdBeginVideoCodingKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginVideoCodingKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginVideoCodingKHR);
     if (strcmp(pName, "vkCmdEndVideoCodingKHR") == 0 && (!device || device_dispatch_table(device)->CmdEndVideoCodingKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndVideoCodingKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndVideoCodingKHR);
     if (strcmp(pName, "vkCmdControlVideoCodingKHR") == 0 && (!device || device_dispatch_table(device)->CmdControlVideoCodingKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdControlVideoCodingKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdControlVideoCodingKHR);
     if (strcmp(pName, "vkCmdDecodeVideoKHR") == 0 && (!device || device_dispatch_table(device)->CmdDecodeVideoKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecodeVideoKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecodeVideoKHR);
     if (strcmp(pName, "vkCmdBeginRenderingKHR") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderingKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderingKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderingKHR);
     if (strcmp(pName, "vkCmdEndRenderingKHR") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderingKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderingKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderingKHR);
     if (strcmp(pName, "vkGetDeviceGroupPeerMemoryFeaturesKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupPeerMemoryFeaturesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupPeerMemoryFeaturesKHR);
     if (strcmp(pName, "vkCmdSetDeviceMaskKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetDeviceMaskKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDeviceMaskKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDeviceMaskKHR);
     if (strcmp(pName, "vkCmdDispatchBaseKHR") == 0 && (!device || device_dispatch_table(device)->CmdDispatchBaseKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchBaseKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchBaseKHR);
     if (strcmp(pName, "vkTrimCommandPoolKHR") == 0 && (!device || device_dispatch_table(device)->TrimCommandPoolKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkTrimCommandPoolKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkTrimCommandPoolKHR);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkGetMemoryWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryWin32HandleKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryWin32HandleKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryWin32HandleKHR);
     if (strcmp(pName, "vkGetMemoryWin32HandlePropertiesKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryWin32HandlePropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryWin32HandlePropertiesKHR);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkGetMemoryFdKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryFdKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryFdKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryFdKHR);
     if (strcmp(pName, "vkGetMemoryFdPropertiesKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryFdPropertiesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryFdPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryFdPropertiesKHR);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkImportSemaphoreWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkImportSemaphoreWin32HandleKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkImportSemaphoreWin32HandleKHR);
     if (strcmp(pName, "vkGetSemaphoreWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreWin32HandleKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreWin32HandleKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreWin32HandleKHR);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkImportSemaphoreFdKHR") == 0 && (!device || device_dispatch_table(device)->ImportSemaphoreFdKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkImportSemaphoreFdKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkImportSemaphoreFdKHR);
     if (strcmp(pName, "vkGetSemaphoreFdKHR") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreFdKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreFdKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreFdKHR);
     if (strcmp(pName, "vkCmdPushDescriptorSetKHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetKHR);
     if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplateKHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplateKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplateKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplateKHR);
     if (strcmp(pName, "vkCreateDescriptorUpdateTemplateKHR") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorUpdateTemplateKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorUpdateTemplateKHR);
     if (strcmp(pName, "vkDestroyDescriptorUpdateTemplateKHR") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorUpdateTemplateKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorUpdateTemplateKHR);
     if (strcmp(pName, "vkUpdateDescriptorSetWithTemplateKHR") == 0 && (!device || device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSetWithTemplateKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSetWithTemplateKHR);
     if (strcmp(pName, "vkCreateRenderPass2KHR") == 0 && (!device || device_dispatch_table(device)->CreateRenderPass2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass2KHR);
     if (strcmp(pName, "vkCmdBeginRenderPass2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderPass2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass2KHR);
     if (strcmp(pName, "vkCmdNextSubpass2KHR") == 0 && (!device || device_dispatch_table(device)->CmdNextSubpass2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass2KHR);
     if (strcmp(pName, "vkCmdEndRenderPass2KHR") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderPass2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass2KHR);
     if (strcmp(pName, "vkGetSwapchainStatusKHR") == 0 && (!device || device_dispatch_table(device)->GetSwapchainStatusKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainStatusKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainStatusKHR);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkImportFenceWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->ImportFenceWin32HandleKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkImportFenceWin32HandleKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkImportFenceWin32HandleKHR);
     if (strcmp(pName, "vkGetFenceWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->GetFenceWin32HandleKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceWin32HandleKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceWin32HandleKHR);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkImportFenceFdKHR") == 0 && (!device || device_dispatch_table(device)->ImportFenceFdKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkImportFenceFdKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkImportFenceFdKHR);
     if (strcmp(pName, "vkGetFenceFdKHR") == 0 && (!device || device_dispatch_table(device)->GetFenceFdKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceFdKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceFdKHR);
     if (strcmp(pName, "vkAcquireProfilingLockKHR") == 0 && (!device || device_dispatch_table(device)->AcquireProfilingLockKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireProfilingLockKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireProfilingLockKHR);
     if (strcmp(pName, "vkReleaseProfilingLockKHR") == 0 && (!device || device_dispatch_table(device)->ReleaseProfilingLockKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseProfilingLockKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseProfilingLockKHR);
     if (strcmp(pName, "vkGetImageMemoryRequirements2KHR") == 0 && (!device || device_dispatch_table(device)->GetImageMemoryRequirements2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements2KHR);
     if (strcmp(pName, "vkGetBufferMemoryRequirements2KHR") == 0 && (!device || device_dispatch_table(device)->GetBufferMemoryRequirements2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements2KHR);
     if (strcmp(pName, "vkGetImageSparseMemoryRequirements2KHR") == 0 && (!device || device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements2KHR);
     if (strcmp(pName, "vkCreateSamplerYcbcrConversionKHR") == 0 && (!device || device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSamplerYcbcrConversionKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSamplerYcbcrConversionKHR);
     if (strcmp(pName, "vkDestroySamplerYcbcrConversionKHR") == 0 && (!device || device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySamplerYcbcrConversionKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySamplerYcbcrConversionKHR);
     if (strcmp(pName, "vkBindBufferMemory2KHR") == 0 && (!device || device_dispatch_table(device)->BindBufferMemory2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory2KHR);
     if (strcmp(pName, "vkBindImageMemory2KHR") == 0 && (!device || device_dispatch_table(device)->BindImageMemory2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory2KHR);
     if (strcmp(pName, "vkGetDescriptorSetLayoutSupportKHR") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutSupportKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutSupportKHR);
     if (strcmp(pName, "vkCmdDrawIndirectCountKHR") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectCountKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectCountKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectCountKHR);
     if (strcmp(pName, "vkCmdDrawIndexedIndirectCountKHR") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirectCountKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirectCountKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirectCountKHR);
     if (strcmp(pName, "vkGetSemaphoreCounterValueKHR") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreCounterValueKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreCounterValueKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreCounterValueKHR);
     if (strcmp(pName, "vkWaitSemaphoresKHR") == 0 && (!device || device_dispatch_table(device)->WaitSemaphoresKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitSemaphoresKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitSemaphoresKHR);
     if (strcmp(pName, "vkSignalSemaphoreKHR") == 0 && (!device || device_dispatch_table(device)->SignalSemaphoreKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSignalSemaphoreKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSignalSemaphoreKHR);
     if (strcmp(pName, "vkCmdSetFragmentShadingRateKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetFragmentShadingRateKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFragmentShadingRateKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFragmentShadingRateKHR);
     if (strcmp(pName, "vkCmdSetRenderingAttachmentLocationsKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingAttachmentLocationsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingAttachmentLocationsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingAttachmentLocationsKHR);
     if (strcmp(pName, "vkCmdSetRenderingInputAttachmentIndicesKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingInputAttachmentIndicesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingInputAttachmentIndicesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRenderingInputAttachmentIndicesKHR);
     if (strcmp(pName, "vkWaitForPresentKHR") == 0 && (!device || device_dispatch_table(device)->WaitForPresentKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitForPresentKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitForPresentKHR);
     if (strcmp(pName, "vkGetBufferDeviceAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetBufferDeviceAddressKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferDeviceAddressKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferDeviceAddressKHR);
     if (strcmp(pName, "vkGetBufferOpaqueCaptureAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferOpaqueCaptureAddressKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferOpaqueCaptureAddressKHR);
     if (strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryOpaqueCaptureAddressKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryOpaqueCaptureAddressKHR);
     if (strcmp(pName, "vkCreateDeferredOperationKHR") == 0 && (!device || device_dispatch_table(device)->CreateDeferredOperationKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDeferredOperationKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDeferredOperationKHR);
     if (strcmp(pName, "vkDestroyDeferredOperationKHR") == 0 && (!device || device_dispatch_table(device)->DestroyDeferredOperationKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDeferredOperationKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDeferredOperationKHR);
     if (strcmp(pName, "vkGetDeferredOperationMaxConcurrencyKHR") == 0 && (!device || device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeferredOperationMaxConcurrencyKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeferredOperationMaxConcurrencyKHR);
     if (strcmp(pName, "vkGetDeferredOperationResultKHR") == 0 && (!device || device_dispatch_table(device)->GetDeferredOperationResultKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeferredOperationResultKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeferredOperationResultKHR);
     if (strcmp(pName, "vkDeferredOperationJoinKHR") == 0 && (!device || device_dispatch_table(device)->DeferredOperationJoinKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDeferredOperationJoinKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDeferredOperationJoinKHR);
     if (strcmp(pName, "vkGetPipelineExecutablePropertiesKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineExecutablePropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineExecutablePropertiesKHR);
     if (strcmp(pName, "vkGetPipelineExecutableStatisticsKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineExecutableStatisticsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineExecutableStatisticsKHR);
     if (strcmp(pName, "vkGetPipelineExecutableInternalRepresentationsKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineExecutableInternalRepresentationsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineExecutableInternalRepresentationsKHR);
     if (strcmp(pName, "vkMapMemory2KHR") == 0 && (!device || device_dispatch_table(device)->MapMemory2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory2KHR);
     if (strcmp(pName, "vkUnmapMemory2KHR") == 0 && (!device || device_dispatch_table(device)->UnmapMemory2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory2KHR);
     if (strcmp(pName, "vkGetEncodedVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetEncodedVideoSessionParametersKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetEncodedVideoSessionParametersKHR);
     if (strcmp(pName, "vkCmdEncodeVideoKHR") == 0 && (!device || device_dispatch_table(device)->CmdEncodeVideoKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEncodeVideoKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEncodeVideoKHR);
     if (strcmp(pName, "vkCmdSetEvent2KHR") == 0 && (!device || device_dispatch_table(device)->CmdSetEvent2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent2KHR);
     if (strcmp(pName, "vkCmdResetEvent2KHR") == 0 && (!device || device_dispatch_table(device)->CmdResetEvent2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent2KHR);
     if (strcmp(pName, "vkCmdWaitEvents2KHR") == 0 && (!device || device_dispatch_table(device)->CmdWaitEvents2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents2KHR);
     if (strcmp(pName, "vkCmdPipelineBarrier2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPipelineBarrier2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier2KHR);
     if (strcmp(pName, "vkCmdWriteTimestamp2KHR") == 0 && (!device || device_dispatch_table(device)->CmdWriteTimestamp2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp2KHR);
     if (strcmp(pName, "vkQueueSubmit2KHR") == 0 && (!device || device_dispatch_table(device)->QueueSubmit2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit2KHR);
     if (strcmp(pName, "vkCmdCopyBuffer2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyBuffer2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer2KHR);
     if (strcmp(pName, "vkCmdCopyImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyImage2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage2KHR);
     if (strcmp(pName, "vkCmdCopyBufferToImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyBufferToImage2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage2KHR);
     if (strcmp(pName, "vkCmdCopyImageToBuffer2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyImageToBuffer2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer2KHR);
     if (strcmp(pName, "vkCmdBlitImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBlitImage2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage2KHR);
     if (strcmp(pName, "vkCmdResolveImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdResolveImage2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage2KHR);
     if (strcmp(pName, "vkCmdTraceRaysIndirect2KHR") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysIndirect2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysIndirect2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysIndirect2KHR);
     if (strcmp(pName, "vkGetDeviceBufferMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceBufferMemoryRequirementsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceBufferMemoryRequirementsKHR);
     if (strcmp(pName, "vkGetDeviceImageMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageMemoryRequirementsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageMemoryRequirementsKHR);
     if (strcmp(pName, "vkGetDeviceImageSparseMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSparseMemoryRequirementsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSparseMemoryRequirementsKHR);
     if (strcmp(pName, "vkCmdBindIndexBuffer2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBindIndexBuffer2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer2KHR);
     if (strcmp(pName, "vkGetRenderingAreaGranularityKHR") == 0 && (!device || device_dispatch_table(device)->GetRenderingAreaGranularityKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderingAreaGranularityKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderingAreaGranularityKHR);
     if (strcmp(pName, "vkGetDeviceImageSubresourceLayoutKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSubresourceLayoutKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceImageSubresourceLayoutKHR);
     if (strcmp(pName, "vkGetImageSubresourceLayout2KHR") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout2KHR);
     if (strcmp(pName, "vkWaitForPresent2KHR") == 0 && (!device || device_dispatch_table(device)->WaitForPresent2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitForPresent2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWaitForPresent2KHR);
     if (strcmp(pName, "vkCreatePipelineBinariesKHR") == 0 && (!device || device_dispatch_table(device)->CreatePipelineBinariesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineBinariesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineBinariesKHR);
     if (strcmp(pName, "vkDestroyPipelineBinaryKHR") == 0 && (!device || device_dispatch_table(device)->DestroyPipelineBinaryKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineBinaryKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineBinaryKHR);
     if (strcmp(pName, "vkGetPipelineKeyKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineKeyKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineKeyKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineKeyKHR);
     if (strcmp(pName, "vkGetPipelineBinaryDataKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineBinaryDataKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineBinaryDataKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineBinaryDataKHR);
     if (strcmp(pName, "vkReleaseCapturedPipelineDataKHR") == 0 && (!device || device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseCapturedPipelineDataKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseCapturedPipelineDataKHR);
     if (strcmp(pName, "vkReleaseSwapchainImagesKHR") == 0 && (!device || device_dispatch_table(device)->ReleaseSwapchainImagesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseSwapchainImagesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseSwapchainImagesKHR);
     if (strcmp(pName, "vkCmdSetLineStippleKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStippleKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStippleKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStippleKHR);
     if (strcmp(pName, "vkGetCalibratedTimestampsKHR") == 0 && (!device || device_dispatch_table(device)->GetCalibratedTimestampsKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetCalibratedTimestampsKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetCalibratedTimestampsKHR);
     if (strcmp(pName, "vkCmdBindDescriptorSets2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorSets2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets2KHR);
     if (strcmp(pName, "vkCmdPushConstants2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPushConstants2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants2KHR);
     if (strcmp(pName, "vkCmdPushDescriptorSet2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSet2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSet2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSet2KHR);
     if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplate2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplate2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplate2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDescriptorSetWithTemplate2KHR);
     if (strcmp(pName, "vkCmdSetDescriptorBufferOffsets2EXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDescriptorBufferOffsets2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDescriptorBufferOffsets2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDescriptorBufferOffsets2EXT);
     if (strcmp(pName, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorBufferEmbeddedSamplers2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT);
     if (strcmp(pName, "vkCmdCopyMemoryIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryIndirectKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryIndirectKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryIndirectKHR);
     if (strcmp(pName, "vkCmdCopyMemoryToImageIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToImageIndirectKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToImageIndirectKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToImageIndirectKHR);
     if (strcmp(pName, "vkCmdEndRendering2KHR") == 0 && (!device || device_dispatch_table(device)->CmdEndRendering2KHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRendering2KHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRendering2KHR);
     if (strcmp(pName, "vkDebugMarkerSetObjectTagEXT") == 0 && (!device || device_dispatch_table(device)->DebugMarkerSetObjectTagEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDebugMarkerSetObjectTagEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDebugMarkerSetObjectTagEXT);
     if (strcmp(pName, "vkDebugMarkerSetObjectNameEXT") == 0 && (!device || device_dispatch_table(device)->DebugMarkerSetObjectNameEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDebugMarkerSetObjectNameEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDebugMarkerSetObjectNameEXT);
     if (strcmp(pName, "vkCmdDebugMarkerBeginEXT") == 0 && (!device || device_dispatch_table(device)->CmdDebugMarkerBeginEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDebugMarkerBeginEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDebugMarkerBeginEXT);
     if (strcmp(pName, "vkCmdDebugMarkerEndEXT") == 0 && (!device || device_dispatch_table(device)->CmdDebugMarkerEndEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDebugMarkerEndEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDebugMarkerEndEXT);
     if (strcmp(pName, "vkCmdDebugMarkerInsertEXT") == 0 && (!device || device_dispatch_table(device)->CmdDebugMarkerInsertEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDebugMarkerInsertEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDebugMarkerInsertEXT);
     if (strcmp(pName, "vkCmdBindTransformFeedbackBuffersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindTransformFeedbackBuffersEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindTransformFeedbackBuffersEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindTransformFeedbackBuffersEXT);
     if (strcmp(pName, "vkCmdBeginTransformFeedbackEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginTransformFeedbackEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginTransformFeedbackEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginTransformFeedbackEXT);
     if (strcmp(pName, "vkCmdEndTransformFeedbackEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndTransformFeedbackEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndTransformFeedbackEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndTransformFeedbackEXT);
     if (strcmp(pName, "vkCmdBeginQueryIndexedEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginQueryIndexedEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQueryIndexedEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQueryIndexedEXT);
     if (strcmp(pName, "vkCmdEndQueryIndexedEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndQueryIndexedEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQueryIndexedEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQueryIndexedEXT);
     if (strcmp(pName, "vkCmdDrawIndirectByteCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectByteCountEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectByteCountEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectByteCountEXT);
     if (strcmp(pName, "vkCreateCuModuleNVX") == 0 && (!device || device_dispatch_table(device)->CreateCuModuleNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCuModuleNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCuModuleNVX);
     if (strcmp(pName, "vkCreateCuFunctionNVX") == 0 && (!device || device_dispatch_table(device)->CreateCuFunctionNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCuFunctionNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCuFunctionNVX);
     if (strcmp(pName, "vkDestroyCuModuleNVX") == 0 && (!device || device_dispatch_table(device)->DestroyCuModuleNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCuModuleNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCuModuleNVX);
     if (strcmp(pName, "vkDestroyCuFunctionNVX") == 0 && (!device || device_dispatch_table(device)->DestroyCuFunctionNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCuFunctionNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCuFunctionNVX);
     if (strcmp(pName, "vkCmdCuLaunchKernelNVX") == 0 && (!device || device_dispatch_table(device)->CmdCuLaunchKernelNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCuLaunchKernelNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCuLaunchKernelNVX);
     if (strcmp(pName, "vkGetImageViewHandleNVX") == 0 && (!device || device_dispatch_table(device)->GetImageViewHandleNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewHandleNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewHandleNVX);
     if (strcmp(pName, "vkGetImageViewHandle64NVX") == 0 && (!device || device_dispatch_table(device)->GetImageViewHandle64NVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewHandle64NVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewHandle64NVX);
     if (strcmp(pName, "vkGetImageViewAddressNVX") == 0 && (!device || device_dispatch_table(device)->GetImageViewAddressNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewAddressNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewAddressNVX);
     if (strcmp(pName, "vkGetDeviceCombinedImageSamplerIndexNVX") == 0 && (!device || device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceCombinedImageSamplerIndexNVX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceCombinedImageSamplerIndexNVX);
     if (strcmp(pName, "vkCmdDrawIndirectCountAMD") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectCountAMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectCountAMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirectCountAMD);
     if (strcmp(pName, "vkCmdDrawIndexedIndirectCountAMD") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirectCountAMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirectCountAMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirectCountAMD);
     if (strcmp(pName, "vkGetShaderInfoAMD") == 0 && (!device || device_dispatch_table(device)->GetShaderInfoAMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderInfoAMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderInfoAMD);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkGetMemoryWin32HandleNV") == 0 && (!device || device_dispatch_table(device)->GetMemoryWin32HandleNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryWin32HandleNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryWin32HandleNV);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkCmdBeginConditionalRenderingEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginConditionalRenderingEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginConditionalRenderingEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginConditionalRenderingEXT);
     if (strcmp(pName, "vkCmdEndConditionalRenderingEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndConditionalRenderingEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndConditionalRenderingEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndConditionalRenderingEXT);
     if (strcmp(pName, "vkCmdSetViewportWScalingNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWScalingNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWScalingNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWScalingNV);
     if (strcmp(pName, "vkDisplayPowerControlEXT") == 0 && (!device || device_dispatch_table(device)->DisplayPowerControlEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDisplayPowerControlEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDisplayPowerControlEXT);
     if (strcmp(pName, "vkRegisterDeviceEventEXT") == 0 && (!device || device_dispatch_table(device)->RegisterDeviceEventEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkRegisterDeviceEventEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkRegisterDeviceEventEXT);
     if (strcmp(pName, "vkRegisterDisplayEventEXT") == 0 && (!device || device_dispatch_table(device)->RegisterDisplayEventEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkRegisterDisplayEventEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkRegisterDisplayEventEXT);
     if (strcmp(pName, "vkGetSwapchainCounterEXT") == 0 && (!device || device_dispatch_table(device)->GetSwapchainCounterEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainCounterEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainCounterEXT);
     if (strcmp(pName, "vkGetRefreshCycleDurationGOOGLE") == 0 && (!device || device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRefreshCycleDurationGOOGLE<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRefreshCycleDurationGOOGLE);
     if (strcmp(pName, "vkGetPastPresentationTimingGOOGLE") == 0 && (!device || device_dispatch_table(device)->GetPastPresentationTimingGOOGLE))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPastPresentationTimingGOOGLE<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPastPresentationTimingGOOGLE);
     if (strcmp(pName, "vkCmdSetDiscardRectangleEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDiscardRectangleEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDiscardRectangleEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDiscardRectangleEXT);
     if (strcmp(pName, "vkCmdSetDiscardRectangleEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDiscardRectangleEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDiscardRectangleEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDiscardRectangleEnableEXT);
     if (strcmp(pName, "vkCmdSetDiscardRectangleModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDiscardRectangleModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDiscardRectangleModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDiscardRectangleModeEXT);
     if (strcmp(pName, "vkSetHdrMetadataEXT") == 0 && (!device || device_dispatch_table(device)->SetHdrMetadataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetHdrMetadataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetHdrMetadataEXT);
     if (strcmp(pName, "vkSetDebugUtilsObjectNameEXT") == 0 && (!device || device_dispatch_table(device)->SetDebugUtilsObjectNameEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectNameEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectNameEXT);
     if (strcmp(pName, "vkSetDebugUtilsObjectTagEXT") == 0 && (!device || device_dispatch_table(device)->SetDebugUtilsObjectTagEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectTagEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDebugUtilsObjectTagEXT);
     if (strcmp(pName, "vkQueueBeginDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->QueueBeginDebugUtilsLabelEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueBeginDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueBeginDebugUtilsLabelEXT);
     if (strcmp(pName, "vkQueueEndDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->QueueEndDebugUtilsLabelEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueEndDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueEndDebugUtilsLabelEXT);
     if (strcmp(pName, "vkQueueInsertDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->QueueInsertDebugUtilsLabelEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueInsertDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueInsertDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCmdBeginDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginDebugUtilsLabelEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCmdEndDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndDebugUtilsLabelEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndDebugUtilsLabelEXT);
     if (strcmp(pName, "vkCmdInsertDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->CmdInsertDebugUtilsLabelEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdInsertDebugUtilsLabelEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdInsertDebugUtilsLabelEXT);
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
     if (strcmp(pName, "vkGetAndroidHardwareBufferPropertiesANDROID") == 0 && (!device || device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAndroidHardwareBufferPropertiesANDROID<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAndroidHardwareBufferPropertiesANDROID);
     if (strcmp(pName, "vkGetMemoryAndroidHardwareBufferANDROID") == 0 && (!device || device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryAndroidHardwareBufferANDROID<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryAndroidHardwareBufferANDROID);
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
     if (strcmp(pName, "vkCreateExecutionGraphPipelinesAMDX") == 0 && (!device || device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateExecutionGraphPipelinesAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateExecutionGraphPipelinesAMDX);
     if (strcmp(pName, "vkGetExecutionGraphPipelineScratchSizeAMDX") == 0 && (!device || device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetExecutionGraphPipelineScratchSizeAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetExecutionGraphPipelineScratchSizeAMDX);
     if (strcmp(pName, "vkGetExecutionGraphPipelineNodeIndexAMDX") == 0 && (!device || device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetExecutionGraphPipelineNodeIndexAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetExecutionGraphPipelineNodeIndexAMDX);
     if (strcmp(pName, "vkCmdInitializeGraphScratchMemoryAMDX") == 0 && (!device || device_dispatch_table(device)->CmdInitializeGraphScratchMemoryAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdInitializeGraphScratchMemoryAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdInitializeGraphScratchMemoryAMDX);
     if (strcmp(pName, "vkCmdDispatchGraphAMDX") == 0 && (!device || device_dispatch_table(device)->CmdDispatchGraphAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchGraphAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchGraphAMDX);
     if (strcmp(pName, "vkCmdDispatchGraphIndirectAMDX") == 0 && (!device || device_dispatch_table(device)->CmdDispatchGraphIndirectAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchGraphIndirectAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchGraphIndirectAMDX);
     if (strcmp(pName, "vkCmdDispatchGraphIndirectCountAMDX") == 0 && (!device || device_dispatch_table(device)->CmdDispatchGraphIndirectCountAMDX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchGraphIndirectCountAMDX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchGraphIndirectCountAMDX);
 #endif  // VK_ENABLE_BETA_EXTENSIONS
     if (strcmp(pName, "vkWriteSamplerDescriptorsEXT") == 0 && (!device || device_dispatch_table(device)->WriteSamplerDescriptorsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteSamplerDescriptorsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteSamplerDescriptorsEXT);
     if (strcmp(pName, "vkWriteResourceDescriptorsEXT") == 0 && (!device || device_dispatch_table(device)->WriteResourceDescriptorsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteResourceDescriptorsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteResourceDescriptorsEXT);
     if (strcmp(pName, "vkCmdBindSamplerHeapEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindSamplerHeapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindSamplerHeapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindSamplerHeapEXT);
     if (strcmp(pName, "vkCmdBindResourceHeapEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindResourceHeapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindResourceHeapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindResourceHeapEXT);
     if (strcmp(pName, "vkCmdPushDataEXT") == 0 && (!device || device_dispatch_table(device)->CmdPushDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushDataEXT);
     if (strcmp(pName, "vkGetImageOpaqueCaptureDataEXT") == 0 && (!device || device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageOpaqueCaptureDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageOpaqueCaptureDataEXT);
     if (strcmp(pName, "vkRegisterCustomBorderColorEXT") == 0 && (!device || device_dispatch_table(device)->RegisterCustomBorderColorEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkRegisterCustomBorderColorEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkRegisterCustomBorderColorEXT);
     if (strcmp(pName, "vkUnregisterCustomBorderColorEXT") == 0 && (!device || device_dispatch_table(device)->UnregisterCustomBorderColorEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUnregisterCustomBorderColorEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUnregisterCustomBorderColorEXT);
     if (strcmp(pName, "vkGetTensorOpaqueCaptureDataARM") == 0 && (!device || device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorOpaqueCaptureDataARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorOpaqueCaptureDataARM);
     if (strcmp(pName, "vkCmdSetSampleLocationsEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetSampleLocationsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetSampleLocationsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetSampleLocationsEXT);
     if (strcmp(pName, "vkGetImageDrmFormatModifierPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageDrmFormatModifierPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageDrmFormatModifierPropertiesEXT);
     if (strcmp(pName, "vkCreateValidationCacheEXT") == 0 && (!device || device_dispatch_table(device)->CreateValidationCacheEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateValidationCacheEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateValidationCacheEXT);
     if (strcmp(pName, "vkDestroyValidationCacheEXT") == 0 && (!device || device_dispatch_table(device)->DestroyValidationCacheEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyValidationCacheEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyValidationCacheEXT);
     if (strcmp(pName, "vkMergeValidationCachesEXT") == 0 && (!device || device_dispatch_table(device)->MergeValidationCachesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkMergeValidationCachesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkMergeValidationCachesEXT);
     if (strcmp(pName, "vkGetValidationCacheDataEXT") == 0 && (!device || device_dispatch_table(device)->GetValidationCacheDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetValidationCacheDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetValidationCacheDataEXT);
     if (strcmp(pName, "vkCmdBindShadingRateImageNV") == 0 && (!device || device_dispatch_table(device)->CmdBindShadingRateImageNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindShadingRateImageNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindShadingRateImageNV);
     if (strcmp(pName, "vkCmdSetViewportShadingRatePaletteNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportShadingRatePaletteNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportShadingRatePaletteNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportShadingRatePaletteNV);
     if (strcmp(pName, "vkCmdSetCoarseSampleOrderNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoarseSampleOrderNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoarseSampleOrderNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoarseSampleOrderNV);
     if (strcmp(pName, "vkCreateAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->CreateAccelerationStructureNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateAccelerationStructureNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateAccelerationStructureNV);
     if (strcmp(pName, "vkDestroyAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->DestroyAccelerationStructureNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyAccelerationStructureNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyAccelerationStructureNV);
     if (strcmp(pName, "vkGetAccelerationStructureMemoryRequirementsNV") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureMemoryRequirementsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureMemoryRequirementsNV);
     if (strcmp(pName, "vkBindAccelerationStructureMemoryNV") == 0 && (!device || device_dispatch_table(device)->BindAccelerationStructureMemoryNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindAccelerationStructureMemoryNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindAccelerationStructureMemoryNV);
     if (strcmp(pName, "vkCmdBuildAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->CmdBuildAccelerationStructureNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildAccelerationStructureNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildAccelerationStructureNV);
     if (strcmp(pName, "vkCmdCopyAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->CmdCopyAccelerationStructureNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyAccelerationStructureNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyAccelerationStructureNV);
     if (strcmp(pName, "vkCmdTraceRaysNV") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysNV);
     if (strcmp(pName, "vkCreateRayTracingPipelinesNV") == 0 && (!device || device_dispatch_table(device)->CreateRayTracingPipelinesNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRayTracingPipelinesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRayTracingPipelinesNV);
     if (strcmp(pName, "vkGetRayTracingShaderGroupHandlesKHR") == 0 && (!device || device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingShaderGroupHandlesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingShaderGroupHandlesKHR);
     if (strcmp(pName, "vkGetRayTracingShaderGroupHandlesNV") == 0 && (!device || device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingShaderGroupHandlesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingShaderGroupHandlesNV);
     if (strcmp(pName, "vkGetAccelerationStructureHandleNV") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureHandleNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureHandleNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureHandleNV);
     if (strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesNV") == 0 && (!device || device_dispatch_table(device)->CmdWriteAccelerationStructuresPropertiesNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteAccelerationStructuresPropertiesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteAccelerationStructuresPropertiesNV);
     if (strcmp(pName, "vkCompileDeferredNV") == 0 && (!device || device_dispatch_table(device)->CompileDeferredNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCompileDeferredNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCompileDeferredNV);
     if (strcmp(pName, "vkGetMemoryHostPointerPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryHostPointerPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryHostPointerPropertiesEXT);
     if (strcmp(pName, "vkCmdWriteBufferMarkerAMD") == 0 && (!device || device_dispatch_table(device)->CmdWriteBufferMarkerAMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteBufferMarkerAMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteBufferMarkerAMD);
     if (strcmp(pName, "vkCmdWriteBufferMarker2AMD") == 0 && (!device || device_dispatch_table(device)->CmdWriteBufferMarker2AMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteBufferMarker2AMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteBufferMarker2AMD);
     if (strcmp(pName, "vkGetCalibratedTimestampsEXT") == 0 && (!device || device_dispatch_table(device)->GetCalibratedTimestampsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetCalibratedTimestampsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetCalibratedTimestampsEXT);
     if (strcmp(pName, "vkCmdDrawMeshTasksNV") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksNV);
     if (strcmp(pName, "vkCmdDrawMeshTasksIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectNV);
     if (strcmp(pName, "vkCmdDrawMeshTasksIndirectCountNV") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectCountNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectCountNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectCountNV);
     if (strcmp(pName, "vkCmdSetExclusiveScissorEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetExclusiveScissorEnableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetExclusiveScissorEnableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetExclusiveScissorEnableNV);
     if (strcmp(pName, "vkCmdSetExclusiveScissorNV") == 0 && (!device || device_dispatch_table(device)->CmdSetExclusiveScissorNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetExclusiveScissorNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetExclusiveScissorNV);
     if (strcmp(pName, "vkCmdSetCheckpointNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCheckpointNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCheckpointNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCheckpointNV);
     if (strcmp(pName, "vkGetQueueCheckpointDataNV") == 0 && (!device || device_dispatch_table(device)->GetQueueCheckpointDataNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetQueueCheckpointDataNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetQueueCheckpointDataNV);
     if (strcmp(pName, "vkGetQueueCheckpointData2NV") == 0 && (!device || device_dispatch_table(device)->GetQueueCheckpointData2NV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetQueueCheckpointData2NV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetQueueCheckpointData2NV);
     if (strcmp(pName, "vkSetSwapchainPresentTimingQueueSizeEXT") == 0 && (!device || device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetSwapchainPresentTimingQueueSizeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetSwapchainPresentTimingQueueSizeEXT);
     if (strcmp(pName, "vkGetSwapchainTimingPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainTimingPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainTimingPropertiesEXT);
     if (strcmp(pName, "vkGetSwapchainTimeDomainPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainTimeDomainPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainTimeDomainPropertiesEXT);
     if (strcmp(pName, "vkGetPastPresentationTimingEXT") == 0 && (!device || device_dispatch_table(device)->GetPastPresentationTimingEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPastPresentationTimingEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPastPresentationTimingEXT);
     if (strcmp(pName, "vkInitializePerformanceApiINTEL") == 0 && (!device || device_dispatch_table(device)->InitializePerformanceApiINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkInitializePerformanceApiINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkInitializePerformanceApiINTEL);
     if (strcmp(pName, "vkUninitializePerformanceApiINTEL") == 0 && (!device || device_dispatch_table(device)->UninitializePerformanceApiINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUninitializePerformanceApiINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUninitializePerformanceApiINTEL);
     if (strcmp(pName, "vkCmdSetPerformanceMarkerINTEL") == 0 && (!device || device_dispatch_table(device)->CmdSetPerformanceMarkerINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPerformanceMarkerINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPerformanceMarkerINTEL);
     if (strcmp(pName, "vkCmdSetPerformanceStreamMarkerINTEL") == 0 && (!device || device_dispatch_table(device)->CmdSetPerformanceStreamMarkerINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPerformanceStreamMarkerINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPerformanceStreamMarkerINTEL);
     if (strcmp(pName, "vkCmdSetPerformanceOverrideINTEL") == 0 && (!device || device_dispatch_table(device)->CmdSetPerformanceOverrideINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPerformanceOverrideINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPerformanceOverrideINTEL);
     if (strcmp(pName, "vkAcquirePerformanceConfigurationINTEL") == 0 && (!device || device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquirePerformanceConfigurationINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquirePerformanceConfigurationINTEL);
     if (strcmp(pName, "vkReleasePerformanceConfigurationINTEL") == 0 && (!device || device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleasePerformanceConfigurationINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleasePerformanceConfigurationINTEL);
     if (strcmp(pName, "vkQueueSetPerformanceConfigurationINTEL") == 0 && (!device || device_dispatch_table(device)->QueueSetPerformanceConfigurationINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSetPerformanceConfigurationINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueSetPerformanceConfigurationINTEL);
     if (strcmp(pName, "vkGetPerformanceParameterINTEL") == 0 && (!device || device_dispatch_table(device)->GetPerformanceParameterINTEL))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPerformanceParameterINTEL<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPerformanceParameterINTEL);
     if (strcmp(pName, "vkSetLocalDimmingAMD") == 0 && (!device || device_dispatch_table(device)->SetLocalDimmingAMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetLocalDimmingAMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetLocalDimmingAMD);
     if (strcmp(pName, "vkGetBufferDeviceAddressEXT") == 0 && (!device || device_dispatch_table(device)->GetBufferDeviceAddressEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferDeviceAddressEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferDeviceAddressEXT);
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (strcmp(pName, "vkAcquireFullScreenExclusiveModeEXT") == 0 && (!device || device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireFullScreenExclusiveModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireFullScreenExclusiveModeEXT);
     if (strcmp(pName, "vkReleaseFullScreenExclusiveModeEXT") == 0 && (!device || device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseFullScreenExclusiveModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseFullScreenExclusiveModeEXT);
     if (strcmp(pName, "vkGetDeviceGroupSurfacePresentModes2EXT") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupSurfacePresentModes2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceGroupSurfacePresentModes2EXT);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
     if (strcmp(pName, "vkCmdSetLineStippleEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStippleEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStippleEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStippleEXT);
     if (strcmp(pName, "vkResetQueryPoolEXT") == 0 && (!device || device_dispatch_table(device)->ResetQueryPoolEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkResetQueryPoolEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkResetQueryPoolEXT);
     if (strcmp(pName, "vkCmdSetCullModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetCullModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCullModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCullModeEXT);
     if (strcmp(pName, "vkCmdSetFrontFaceEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetFrontFaceEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFrontFaceEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFrontFaceEXT);
     if (strcmp(pName, "vkCmdSetPrimitiveTopologyEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveTopologyEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveTopologyEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveTopologyEXT);
     if (strcmp(pName, "vkCmdSetViewportWithCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWithCountEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWithCountEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWithCountEXT);
     if (strcmp(pName, "vkCmdSetScissorWithCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetScissorWithCountEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissorWithCountEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissorWithCountEXT);
     if (strcmp(pName, "vkCmdBindVertexBuffers2EXT") == 0 && (!device || device_dispatch_table(device)->CmdBindVertexBuffers2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers2EXT);
     if (strcmp(pName, "vkCmdSetDepthTestEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthTestEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthTestEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthTestEnableEXT);
     if (strcmp(pName, "vkCmdSetDepthWriteEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthWriteEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthWriteEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthWriteEnableEXT);
     if (strcmp(pName, "vkCmdSetDepthCompareOpEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthCompareOpEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthCompareOpEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthCompareOpEXT);
     if (strcmp(pName, "vkCmdSetDepthBoundsTestEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBoundsTestEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBoundsTestEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBoundsTestEnableEXT);
     if (strcmp(pName, "vkCmdSetStencilTestEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilTestEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilTestEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilTestEnableEXT);
     if (strcmp(pName, "vkCmdSetStencilOpEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilOpEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilOpEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilOpEXT);
     if (strcmp(pName, "vkCopyMemoryToImageEXT") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToImageEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToImageEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToImageEXT);
     if (strcmp(pName, "vkCopyImageToMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CopyImageToMemoryEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToMemoryEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToMemoryEXT);
     if (strcmp(pName, "vkCopyImageToImageEXT") == 0 && (!device || device_dispatch_table(device)->CopyImageToImageEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToImageEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyImageToImageEXT);
     if (strcmp(pName, "vkTransitionImageLayoutEXT") == 0 && (!device || device_dispatch_table(device)->TransitionImageLayoutEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkTransitionImageLayoutEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkTransitionImageLayoutEXT);
     if (strcmp(pName, "vkGetImageSubresourceLayout2EXT") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout2EXT);
     if (strcmp(pName, "vkReleaseSwapchainImagesEXT") == 0 && (!device || device_dispatch_table(device)->ReleaseSwapchainImagesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseSwapchainImagesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkReleaseSwapchainImagesEXT);
     if (strcmp(pName, "vkGetGeneratedCommandsMemoryRequirementsNV") == 0 && (!device || device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetGeneratedCommandsMemoryRequirementsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetGeneratedCommandsMemoryRequirementsNV);
     if (strcmp(pName, "vkCmdPreprocessGeneratedCommandsNV") == 0 && (!device || device_dispatch_table(device)->CmdPreprocessGeneratedCommandsNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPreprocessGeneratedCommandsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPreprocessGeneratedCommandsNV);
     if (strcmp(pName, "vkCmdExecuteGeneratedCommandsNV") == 0 && (!device || device_dispatch_table(device)->CmdExecuteGeneratedCommandsNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteGeneratedCommandsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteGeneratedCommandsNV);
     if (strcmp(pName, "vkCmdBindPipelineShaderGroupNV") == 0 && (!device || device_dispatch_table(device)->CmdBindPipelineShaderGroupNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipelineShaderGroupNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipelineShaderGroupNV);
     if (strcmp(pName, "vkCreateIndirectCommandsLayoutNV") == 0 && (!device || device_dispatch_table(device)->CreateIndirectCommandsLayoutNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIndirectCommandsLayoutNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIndirectCommandsLayoutNV);
     if (strcmp(pName, "vkDestroyIndirectCommandsLayoutNV") == 0 && (!device || device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyIndirectCommandsLayoutNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyIndirectCommandsLayoutNV);
     if (strcmp(pName, "vkCmdSetDepthBias2EXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBias2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias2EXT);
     if (strcmp(pName, "vkCreatePrivateDataSlotEXT") == 0 && (!device || device_dispatch_table(device)->CreatePrivateDataSlotEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePrivateDataSlotEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreatePrivateDataSlotEXT);
     if (strcmp(pName, "vkDestroyPrivateDataSlotEXT") == 0 && (!device || device_dispatch_table(device)->DestroyPrivateDataSlotEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPrivateDataSlotEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPrivateDataSlotEXT);
     if (strcmp(pName, "vkSetPrivateDataEXT") == 0 && (!device || device_dispatch_table(device)->SetPrivateDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetPrivateDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetPrivateDataEXT);
     if (strcmp(pName, "vkGetPrivateDataEXT") == 0 && (!device || device_dispatch_table(device)->GetPrivateDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPrivateDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPrivateDataEXT);
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
     if (strcmp(pName, "vkCreateCudaModuleNV") == 0 && (!device || device_dispatch_table(device)->CreateCudaModuleNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCudaModuleNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCudaModuleNV);
     if (strcmp(pName, "vkGetCudaModuleCacheNV") == 0 && (!device || device_dispatch_table(device)->GetCudaModuleCacheNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetCudaModuleCacheNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetCudaModuleCacheNV);
     if (strcmp(pName, "vkCreateCudaFunctionNV") == 0 && (!device || device_dispatch_table(device)->CreateCudaFunctionNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCudaFunctionNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateCudaFunctionNV);
     if (strcmp(pName, "vkDestroyCudaModuleNV") == 0 && (!device || device_dispatch_table(device)->DestroyCudaModuleNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCudaModuleNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCudaModuleNV);
     if (strcmp(pName, "vkDestroyCudaFunctionNV") == 0 && (!device || device_dispatch_table(device)->DestroyCudaFunctionNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCudaFunctionNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCudaFunctionNV);
     if (strcmp(pName, "vkCmdCudaLaunchKernelNV") == 0 && (!device || device_dispatch_table(device)->CmdCudaLaunchKernelNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCudaLaunchKernelNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCudaLaunchKernelNV);
 #endif  // VK_ENABLE_BETA_EXTENSIONS
     if (strcmp(pName, "vkCmdDispatchTileQCOM") == 0 && (!device || device_dispatch_table(device)->CmdDispatchTileQCOM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchTileQCOM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchTileQCOM);
     if (strcmp(pName, "vkCmdBeginPerTileExecutionQCOM") == 0 && (!device || device_dispatch_table(device)->CmdBeginPerTileExecutionQCOM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginPerTileExecutionQCOM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginPerTileExecutionQCOM);
     if (strcmp(pName, "vkCmdEndPerTileExecutionQCOM") == 0 && (!device || device_dispatch_table(device)->CmdEndPerTileExecutionQCOM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndPerTileExecutionQCOM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndPerTileExecutionQCOM);
 #if defined(VK_USE_PLATFORM_METAL_EXT)
     if (strcmp(pName, "vkExportMetalObjectsEXT") == 0 && (!device || device_dispatch_table(device)->ExportMetalObjectsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkExportMetalObjectsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkExportMetalObjectsEXT);
 #endif  // VK_USE_PLATFORM_METAL_EXT
     if (strcmp(pName, "vkGetDescriptorSetLayoutSizeEXT") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutSizeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutSizeEXT);
     if (strcmp(pName, "vkGetDescriptorSetLayoutBindingOffsetEXT") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutBindingOffsetEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutBindingOffsetEXT);
     if (strcmp(pName, "vkGetDescriptorEXT") == 0 && (!device || device_dispatch_table(device)->GetDescriptorEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorEXT);
     if (strcmp(pName, "vkCmdBindDescriptorBuffersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorBuffersEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorBuffersEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorBuffersEXT);
     if (strcmp(pName, "vkCmdSetDescriptorBufferOffsetsEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDescriptorBufferOffsetsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDescriptorBufferOffsetsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDescriptorBufferOffsetsEXT);
     if (strcmp(pName, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorBufferEmbeddedSamplersEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorBufferEmbeddedSamplersEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorBufferEmbeddedSamplersEXT);
     if (strcmp(pName, "vkGetBufferOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferOpaqueCaptureDescriptorDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferOpaqueCaptureDescriptorDataEXT);
     if (strcmp(pName, "vkGetImageOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageOpaqueCaptureDescriptorDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageOpaqueCaptureDescriptorDataEXT);
     if (strcmp(pName, "vkGetImageViewOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewOpaqueCaptureDescriptorDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetImageViewOpaqueCaptureDescriptorDataEXT);
     if (strcmp(pName, "vkGetSamplerOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSamplerOpaqueCaptureDescriptorDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSamplerOpaqueCaptureDescriptorDataEXT);
     if (strcmp(pName, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT);
     if (strcmp(pName, "vkCmdSetFragmentShadingRateEnumNV") == 0 && (!device || device_dispatch_table(device)->CmdSetFragmentShadingRateEnumNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFragmentShadingRateEnumNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetFragmentShadingRateEnumNV);
     if (strcmp(pName, "vkGetDeviceFaultInfoEXT") == 0 && (!device || device_dispatch_table(device)->GetDeviceFaultInfoEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceFaultInfoEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceFaultInfoEXT);
     if (strcmp(pName, "vkCmdSetVertexInputEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetVertexInputEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetVertexInputEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetVertexInputEXT);
 #if defined(VK_USE_PLATFORM_FUCHSIA)
     if (strcmp(pName, "vkGetMemoryZirconHandleFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryZirconHandleFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryZirconHandleFUCHSIA);
     if (strcmp(pName, "vkGetMemoryZirconHandlePropertiesFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryZirconHandlePropertiesFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryZirconHandlePropertiesFUCHSIA);
     if (strcmp(pName, "vkImportSemaphoreZirconHandleFUCHSIA") == 0 && (!device || device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkImportSemaphoreZirconHandleFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkImportSemaphoreZirconHandleFUCHSIA);
     if (strcmp(pName, "vkGetSemaphoreZirconHandleFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreZirconHandleFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetSemaphoreZirconHandleFUCHSIA);
     if (strcmp(pName, "vkCreateBufferCollectionFUCHSIA") == 0 && (!device || device_dispatch_table(device)->CreateBufferCollectionFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferCollectionFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferCollectionFUCHSIA);
     if (strcmp(pName, "vkSetBufferCollectionImageConstraintsFUCHSIA") == 0 && (!device || device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetBufferCollectionImageConstraintsFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetBufferCollectionImageConstraintsFUCHSIA);
     if (strcmp(pName, "vkSetBufferCollectionBufferConstraintsFUCHSIA") == 0 && (!device || device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetBufferCollectionBufferConstraintsFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetBufferCollectionBufferConstraintsFUCHSIA);
     if (strcmp(pName, "vkDestroyBufferCollectionFUCHSIA") == 0 && (!device || device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferCollectionFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferCollectionFUCHSIA);
     if (strcmp(pName, "vkGetBufferCollectionPropertiesFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferCollectionPropertiesFUCHSIA<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferCollectionPropertiesFUCHSIA);
 #endif  // VK_USE_PLATFORM_FUCHSIA
     if (strcmp(pName, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") == 0 && (!device || device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI);
     if (strcmp(pName, "vkCmdSubpassShadingHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdSubpassShadingHUAWEI))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSubpassShadingHUAWEI<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSubpassShadingHUAWEI);
     if (strcmp(pName, "vkCmdBindInvocationMaskHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdBindInvocationMaskHUAWEI))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindInvocationMaskHUAWEI<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindInvocationMaskHUAWEI);
     if (strcmp(pName, "vkGetMemoryRemoteAddressNV") == 0 && (!device || device_dispatch_table(device)->GetMemoryRemoteAddressNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryRemoteAddressNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryRemoteAddressNV);
     if (strcmp(pName, "vkGetPipelinePropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetPipelinePropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelinePropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelinePropertiesEXT);
     if (strcmp(pName, "vkCmdSetPatchControlPointsEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPatchControlPointsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPatchControlPointsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPatchControlPointsEXT);
     if (strcmp(pName, "vkCmdSetRasterizerDiscardEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizerDiscardEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizerDiscardEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizerDiscardEnableEXT);
     if (strcmp(pName, "vkCmdSetDepthBiasEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBiasEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBiasEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBiasEnableEXT);
     if (strcmp(pName, "vkCmdSetLogicOpEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLogicOpEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLogicOpEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLogicOpEXT);
     if (strcmp(pName, "vkCmdSetPrimitiveRestartEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveRestartEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveRestartEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPrimitiveRestartEnableEXT);
     if (strcmp(pName, "vkCmdSetColorWriteEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorWriteEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorWriteEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorWriteEnableEXT);
     if (strcmp(pName, "vkCmdDrawMultiEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMultiEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMultiEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMultiEXT);
     if (strcmp(pName, "vkCmdDrawMultiIndexedEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMultiIndexedEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMultiIndexedEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMultiIndexedEXT);
     if (strcmp(pName, "vkCreateMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CreateMicromapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMicromapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateMicromapEXT);
     if (strcmp(pName, "vkDestroyMicromapEXT") == 0 && (!device || device_dispatch_table(device)->DestroyMicromapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyMicromapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyMicromapEXT);
     if (strcmp(pName, "vkCmdBuildMicromapsEXT") == 0 && (!device || device_dispatch_table(device)->CmdBuildMicromapsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildMicromapsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildMicromapsEXT);
     if (strcmp(pName, "vkBuildMicromapsEXT") == 0 && (!device || device_dispatch_table(device)->BuildMicromapsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBuildMicromapsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBuildMicromapsEXT);
     if (strcmp(pName, "vkCopyMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CopyMicromapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMicromapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMicromapEXT);
     if (strcmp(pName, "vkCopyMicromapToMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CopyMicromapToMemoryEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMicromapToMemoryEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMicromapToMemoryEXT);
     if (strcmp(pName, "vkCopyMemoryToMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToMicromapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToMicromapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToMicromapEXT);
     if (strcmp(pName, "vkWriteMicromapsPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->WriteMicromapsPropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteMicromapsPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteMicromapsPropertiesEXT);
     if (strcmp(pName, "vkCmdCopyMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CmdCopyMicromapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMicromapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMicromapEXT);
     if (strcmp(pName, "vkCmdCopyMicromapToMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CmdCopyMicromapToMemoryEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMicromapToMemoryEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMicromapToMemoryEXT);
     if (strcmp(pName, "vkCmdCopyMemoryToMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToMicromapEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToMicromapEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToMicromapEXT);
     if (strcmp(pName, "vkCmdWriteMicromapsPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->CmdWriteMicromapsPropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteMicromapsPropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteMicromapsPropertiesEXT);
     if (strcmp(pName, "vkGetDeviceMicromapCompatibilityEXT") == 0 && (!device || device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMicromapCompatibilityEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMicromapCompatibilityEXT);
     if (strcmp(pName, "vkGetMicromapBuildSizesEXT") == 0 && (!device || device_dispatch_table(device)->GetMicromapBuildSizesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMicromapBuildSizesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMicromapBuildSizesEXT);
     if (strcmp(pName, "vkCmdDrawClusterHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdDrawClusterHUAWEI))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawClusterHUAWEI<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawClusterHUAWEI);
     if (strcmp(pName, "vkCmdDrawClusterIndirectHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdDrawClusterIndirectHUAWEI))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawClusterIndirectHUAWEI<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawClusterIndirectHUAWEI);
     if (strcmp(pName, "vkSetDeviceMemoryPriorityEXT") == 0 && (!device || device_dispatch_table(device)->SetDeviceMemoryPriorityEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDeviceMemoryPriorityEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetDeviceMemoryPriorityEXT);
     if (strcmp(pName, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutHostMappingInfoVALVE<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetLayoutHostMappingInfoVALVE);
     if (strcmp(pName, "vkGetDescriptorSetHostMappingVALVE") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetHostMappingVALVE<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDescriptorSetHostMappingVALVE);
     if (strcmp(pName, "vkCmdCopyMemoryIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryIndirectNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryIndirectNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryIndirectNV);
     if (strcmp(pName, "vkCmdCopyMemoryToImageIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToImageIndirectNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToImageIndirectNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToImageIndirectNV);
     if (strcmp(pName, "vkCmdDecompressMemoryNV") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryNV);
     if (strcmp(pName, "vkCmdDecompressMemoryIndirectCountNV") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryIndirectCountNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryIndirectCountNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryIndirectCountNV);
     if (strcmp(pName, "vkGetPipelineIndirectMemoryRequirementsNV") == 0 && (!device || device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineIndirectMemoryRequirementsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineIndirectMemoryRequirementsNV);
     if (strcmp(pName, "vkCmdUpdatePipelineIndirectBufferNV") == 0 && (!device || device_dispatch_table(device)->CmdUpdatePipelineIndirectBufferNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdatePipelineIndirectBufferNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdatePipelineIndirectBufferNV);
     if (strcmp(pName, "vkGetPipelineIndirectDeviceAddressNV") == 0 && (!device || device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineIndirectDeviceAddressNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineIndirectDeviceAddressNV);
 #if defined(VK_USE_PLATFORM_OHOS)
     if (strcmp(pName, "vkGetNativeBufferPropertiesOHOS") == 0 && (!device || device_dispatch_table(device)->GetNativeBufferPropertiesOHOS))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetNativeBufferPropertiesOHOS<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetNativeBufferPropertiesOHOS);
     if (strcmp(pName, "vkGetMemoryNativeBufferOHOS") == 0 && (!device || device_dispatch_table(device)->GetMemoryNativeBufferOHOS))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryNativeBufferOHOS<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryNativeBufferOHOS);
 #endif  // VK_USE_PLATFORM_OHOS
     if (strcmp(pName, "vkCmdSetDepthClampEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClampEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClampEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClampEnableEXT);
     if (strcmp(pName, "vkCmdSetPolygonModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPolygonModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPolygonModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetPolygonModeEXT);
     if (strcmp(pName, "vkCmdSetRasterizationSamplesEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizationSamplesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizationSamplesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizationSamplesEXT);
     if (strcmp(pName, "vkCmdSetSampleMaskEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetSampleMaskEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetSampleMaskEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetSampleMaskEXT);
     if (strcmp(pName, "vkCmdSetAlphaToCoverageEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetAlphaToCoverageEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetAlphaToCoverageEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetAlphaToCoverageEnableEXT);
     if (strcmp(pName, "vkCmdSetAlphaToOneEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetAlphaToOneEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetAlphaToOneEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetAlphaToOneEnableEXT);
     if (strcmp(pName, "vkCmdSetLogicOpEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLogicOpEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLogicOpEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLogicOpEnableEXT);
     if (strcmp(pName, "vkCmdSetColorBlendEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorBlendEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorBlendEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorBlendEnableEXT);
     if (strcmp(pName, "vkCmdSetColorBlendEquationEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorBlendEquationEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorBlendEquationEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorBlendEquationEXT);
     if (strcmp(pName, "vkCmdSetColorWriteMaskEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorWriteMaskEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorWriteMaskEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorWriteMaskEXT);
     if (strcmp(pName, "vkCmdSetTessellationDomainOriginEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetTessellationDomainOriginEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetTessellationDomainOriginEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetTessellationDomainOriginEXT);
     if (strcmp(pName, "vkCmdSetRasterizationStreamEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizationStreamEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizationStreamEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRasterizationStreamEXT);
     if (strcmp(pName, "vkCmdSetConservativeRasterizationModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetConservativeRasterizationModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetConservativeRasterizationModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetConservativeRasterizationModeEXT);
     if (strcmp(pName, "vkCmdSetExtraPrimitiveOverestimationSizeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetExtraPrimitiveOverestimationSizeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetExtraPrimitiveOverestimationSizeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetExtraPrimitiveOverestimationSizeEXT);
     if (strcmp(pName, "vkCmdSetDepthClipEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClipEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClipEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClipEnableEXT);
     if (strcmp(pName, "vkCmdSetSampleLocationsEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetSampleLocationsEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetSampleLocationsEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetSampleLocationsEnableEXT);
     if (strcmp(pName, "vkCmdSetColorBlendAdvancedEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorBlendAdvancedEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorBlendAdvancedEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetColorBlendAdvancedEXT);
     if (strcmp(pName, "vkCmdSetProvokingVertexModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetProvokingVertexModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetProvokingVertexModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetProvokingVertexModeEXT);
     if (strcmp(pName, "vkCmdSetLineRasterizationModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLineRasterizationModeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineRasterizationModeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineRasterizationModeEXT);
     if (strcmp(pName, "vkCmdSetLineStippleEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStippleEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStippleEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineStippleEnableEXT);
     if (strcmp(pName, "vkCmdSetDepthClipNegativeOneToOneEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClipNegativeOneToOneEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClipNegativeOneToOneEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClipNegativeOneToOneEXT);
     if (strcmp(pName, "vkCmdSetViewportWScalingEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWScalingEnableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWScalingEnableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportWScalingEnableNV);
     if (strcmp(pName, "vkCmdSetViewportSwizzleNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportSwizzleNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportSwizzleNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewportSwizzleNV);
     if (strcmp(pName, "vkCmdSetCoverageToColorEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageToColorEnableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageToColorEnableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageToColorEnableNV);
     if (strcmp(pName, "vkCmdSetCoverageToColorLocationNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageToColorLocationNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageToColorLocationNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageToColorLocationNV);
     if (strcmp(pName, "vkCmdSetCoverageModulationModeNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageModulationModeNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageModulationModeNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageModulationModeNV);
     if (strcmp(pName, "vkCmdSetCoverageModulationTableEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageModulationTableEnableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageModulationTableEnableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageModulationTableEnableNV);
     if (strcmp(pName, "vkCmdSetCoverageModulationTableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageModulationTableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageModulationTableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageModulationTableNV);
     if (strcmp(pName, "vkCmdSetShadingRateImageEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetShadingRateImageEnableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetShadingRateImageEnableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetShadingRateImageEnableNV);
     if (strcmp(pName, "vkCmdSetRepresentativeFragmentTestEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetRepresentativeFragmentTestEnableNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRepresentativeFragmentTestEnableNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRepresentativeFragmentTestEnableNV);
     if (strcmp(pName, "vkCmdSetCoverageReductionModeNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageReductionModeNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageReductionModeNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetCoverageReductionModeNV);
     if (strcmp(pName, "vkCreateTensorARM") == 0 && (!device || device_dispatch_table(device)->CreateTensorARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateTensorARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateTensorARM);
     if (strcmp(pName, "vkDestroyTensorARM") == 0 && (!device || device_dispatch_table(device)->DestroyTensorARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyTensorARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyTensorARM);
     if (strcmp(pName, "vkCreateTensorViewARM") == 0 && (!device || device_dispatch_table(device)->CreateTensorViewARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateTensorViewARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateTensorViewARM);
     if (strcmp(pName, "vkDestroyTensorViewARM") == 0 && (!device || device_dispatch_table(device)->DestroyTensorViewARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyTensorViewARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyTensorViewARM);
     if (strcmp(pName, "vkGetTensorMemoryRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetTensorMemoryRequirementsARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorMemoryRequirementsARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorMemoryRequirementsARM);
     if (strcmp(pName, "vkBindTensorMemoryARM") == 0 && (!device || device_dispatch_table(device)->BindTensorMemoryARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindTensorMemoryARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindTensorMemoryARM);
     if (strcmp(pName, "vkGetDeviceTensorMemoryRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceTensorMemoryRequirementsARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceTensorMemoryRequirementsARM);
     if (strcmp(pName, "vkCmdCopyTensorARM") == 0 && (!device || device_dispatch_table(device)->CmdCopyTensorARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyTensorARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyTensorARM);
     if (strcmp(pName, "vkGetTensorOpaqueCaptureDescriptorDataARM") == 0 && (!device || device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorOpaqueCaptureDescriptorDataARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorOpaqueCaptureDescriptorDataARM);
     if (strcmp(pName, "vkGetTensorViewOpaqueCaptureDescriptorDataARM") == 0 && (!device || device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorViewOpaqueCaptureDescriptorDataARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetTensorViewOpaqueCaptureDescriptorDataARM);
     if (strcmp(pName, "vkGetShaderModuleIdentifierEXT") == 0 && (!device || device_dispatch_table(device)->GetShaderModuleIdentifierEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderModuleIdentifierEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderModuleIdentifierEXT);
     if (strcmp(pName, "vkGetShaderModuleCreateInfoIdentifierEXT") == 0 && (!device || device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderModuleCreateInfoIdentifierEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderModuleCreateInfoIdentifierEXT);
     if (strcmp(pName, "vkCreateOpticalFlowSessionNV") == 0 && (!device || device_dispatch_table(device)->CreateOpticalFlowSessionNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateOpticalFlowSessionNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateOpticalFlowSessionNV);
     if (strcmp(pName, "vkDestroyOpticalFlowSessionNV") == 0 && (!device || device_dispatch_table(device)->DestroyOpticalFlowSessionNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyOpticalFlowSessionNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyOpticalFlowSessionNV);
     if (strcmp(pName, "vkBindOpticalFlowSessionImageNV") == 0 && (!device || device_dispatch_table(device)->BindOpticalFlowSessionImageNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindOpticalFlowSessionImageNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindOpticalFlowSessionImageNV);
     if (strcmp(pName, "vkCmdOpticalFlowExecuteNV") == 0 && (!device || device_dispatch_table(device)->CmdOpticalFlowExecuteNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdOpticalFlowExecuteNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdOpticalFlowExecuteNV);
     if (strcmp(pName, "vkAntiLagUpdateAMD") == 0 && (!device || device_dispatch_table(device)->AntiLagUpdateAMD))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkAntiLagUpdateAMD<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkAntiLagUpdateAMD);
     if (strcmp(pName, "vkCreateShadersEXT") == 0 && (!device || device_dispatch_table(device)->CreateShadersEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateShadersEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateShadersEXT);
     if (strcmp(pName, "vkDestroyShaderEXT") == 0 && (!device || device_dispatch_table(device)->DestroyShaderEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderEXT);
     if (strcmp(pName, "vkGetShaderBinaryDataEXT") == 0 && (!device || device_dispatch_table(device)->GetShaderBinaryDataEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderBinaryDataEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetShaderBinaryDataEXT);
     if (strcmp(pName, "vkCmdBindShadersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindShadersEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindShadersEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindShadersEXT);
     if (strcmp(pName, "vkCmdSetDepthClampRangeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClampRangeEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClampRangeEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthClampRangeEXT);
     if (strcmp(pName, "vkGetFramebufferTilePropertiesQCOM") == 0 && (!device || device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFramebufferTilePropertiesQCOM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetFramebufferTilePropertiesQCOM);
     if (strcmp(pName, "vkGetDynamicRenderingTilePropertiesQCOM") == 0 && (!device || device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDynamicRenderingTilePropertiesQCOM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDynamicRenderingTilePropertiesQCOM);
     if (strcmp(pName, "vkConvertCooperativeVectorMatrixNV") == 0 && (!device || device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkConvertCooperativeVectorMatrixNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkConvertCooperativeVectorMatrixNV);
     if (strcmp(pName, "vkCmdConvertCooperativeVectorMatrixNV") == 0 && (!device || device_dispatch_table(device)->CmdConvertCooperativeVectorMatrixNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdConvertCooperativeVectorMatrixNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdConvertCooperativeVectorMatrixNV);
     if (strcmp(pName, "vkSetLatencySleepModeNV") == 0 && (!device || device_dispatch_table(device)->SetLatencySleepModeNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetLatencySleepModeNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetLatencySleepModeNV);
     if (strcmp(pName, "vkLatencySleepNV") == 0 && (!device || device_dispatch_table(device)->LatencySleepNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkLatencySleepNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkLatencySleepNV);
     if (strcmp(pName, "vkSetLatencyMarkerNV") == 0 && (!device || device_dispatch_table(device)->SetLatencyMarkerNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkSetLatencyMarkerNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkSetLatencyMarkerNV);
     if (strcmp(pName, "vkGetLatencyTimingsNV") == 0 && (!device || device_dispatch_table(device)->GetLatencyTimingsNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetLatencyTimingsNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetLatencyTimingsNV);
     if (strcmp(pName, "vkQueueNotifyOutOfBandNV") == 0 && (!device || device_dispatch_table(device)->QueueNotifyOutOfBandNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueNotifyOutOfBandNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkQueueNotifyOutOfBandNV);
     if (strcmp(pName, "vkCreateDataGraphPipelinesARM") == 0 && (!device || device_dispatch_table(device)->CreateDataGraphPipelinesARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDataGraphPipelinesARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDataGraphPipelinesARM);
     if (strcmp(pName, "vkCreateDataGraphPipelineSessionARM") == 0 && (!device || device_dispatch_table(device)->CreateDataGraphPipelineSessionARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDataGraphPipelineSessionARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateDataGraphPipelineSessionARM);
     if (strcmp(pName, "vkGetDataGraphPipelineSessionBindPointRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelineSessionBindPointRequirementsARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelineSessionBindPointRequirementsARM);
     if (strcmp(pName, "vkGetDataGraphPipelineSessionMemoryRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelineSessionMemoryRequirementsARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelineSessionMemoryRequirementsARM);
     if (strcmp(pName, "vkBindDataGraphPipelineSessionMemoryARM") == 0 && (!device || device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBindDataGraphPipelineSessionMemoryARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBindDataGraphPipelineSessionMemoryARM);
     if (strcmp(pName, "vkDestroyDataGraphPipelineSessionARM") == 0 && (!device || device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDataGraphPipelineSessionARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDataGraphPipelineSessionARM);
     if (strcmp(pName, "vkCmdDispatchDataGraphARM") == 0 && (!device || device_dispatch_table(device)->CmdDispatchDataGraphARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchDataGraphARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchDataGraphARM);
     if (strcmp(pName, "vkGetDataGraphPipelineAvailablePropertiesARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelineAvailablePropertiesARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelineAvailablePropertiesARM);
     if (strcmp(pName, "vkGetDataGraphPipelinePropertiesARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelinePropertiesARM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDataGraphPipelinePropertiesARM);
     if (strcmp(pName, "vkCmdSetAttachmentFeedbackLoopEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetAttachmentFeedbackLoopEnableEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetAttachmentFeedbackLoopEnableEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetAttachmentFeedbackLoopEnableEXT);
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
     if (strcmp(pName, "vkGetScreenBufferPropertiesQNX") == 0 && (!device || device_dispatch_table(device)->GetScreenBufferPropertiesQNX))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetScreenBufferPropertiesQNX<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetScreenBufferPropertiesQNX);
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     if (strcmp(pName, "vkCmdBindTileMemoryQCOM") == 0 && (!device || device_dispatch_table(device)->CmdBindTileMemoryQCOM))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindTileMemoryQCOM<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindTileMemoryQCOM);
     if (strcmp(pName, "vkCmdDecompressMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryEXT);
     if (strcmp(pName, "vkCmdDecompressMemoryIndirectCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryIndirectCountEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryIndirectCountEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDecompressMemoryIndirectCountEXT);
     if (strcmp(pName, "vkCreateExternalComputeQueueNV") == 0 && (!device || device_dispatch_table(device)->CreateExternalComputeQueueNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateExternalComputeQueueNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateExternalComputeQueueNV);
     if (strcmp(pName, "vkDestroyExternalComputeQueueNV") == 0 && (!device || device_dispatch_table(device)->DestroyExternalComputeQueueNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyExternalComputeQueueNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyExternalComputeQueueNV);
     if (strcmp(pName, "vkGetExternalComputeQueueDataNV") == 0 && (!device || device_dispatch_table(device)->GetExternalComputeQueueDataNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetExternalComputeQueueDataNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetExternalComputeQueueDataNV);
     if (strcmp(pName, "vkGetClusterAccelerationStructureBuildSizesNV") == 0 && (!device || device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetClusterAccelerationStructureBuildSizesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetClusterAccelerationStructureBuildSizesNV);
     if (strcmp(pName, "vkCmdBuildClusterAccelerationStructureIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdBuildClusterAccelerationStructureIndirectNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildClusterAccelerationStructureIndirectNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildClusterAccelerationStructureIndirectNV);
     if (strcmp(pName, "vkGetPartitionedAccelerationStructuresBuildSizesNV") == 0 && (!device || device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPartitionedAccelerationStructuresBuildSizesNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetPartitionedAccelerationStructuresBuildSizesNV);
     if (strcmp(pName, "vkCmdBuildPartitionedAccelerationStructuresNV") == 0 && (!device || device_dispatch_table(device)->CmdBuildPartitionedAccelerationStructuresNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildPartitionedAccelerationStructuresNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildPartitionedAccelerationStructuresNV);
     if (strcmp(pName, "vkGetGeneratedCommandsMemoryRequirementsEXT") == 0 && (!device || device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetGeneratedCommandsMemoryRequirementsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetGeneratedCommandsMemoryRequirementsEXT);
     if (strcmp(pName, "vkCmdPreprocessGeneratedCommandsEXT") == 0 && (!device || device_dispatch_table(device)->CmdPreprocessGeneratedCommandsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPreprocessGeneratedCommandsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdPreprocessGeneratedCommandsEXT);
     if (strcmp(pName, "vkCmdExecuteGeneratedCommandsEXT") == 0 && (!device || device_dispatch_table(device)->CmdExecuteGeneratedCommandsEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteGeneratedCommandsEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteGeneratedCommandsEXT);
     if (strcmp(pName, "vkCreateIndirectCommandsLayoutEXT") == 0 && (!device || device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIndirectCommandsLayoutEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIndirectCommandsLayoutEXT);
     if (strcmp(pName, "vkDestroyIndirectCommandsLayoutEXT") == 0 && (!device || device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyIndirectCommandsLayoutEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyIndirectCommandsLayoutEXT);
     if (strcmp(pName, "vkCreateIndirectExecutionSetEXT") == 0 && (!device || device_dispatch_table(device)->CreateIndirectExecutionSetEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIndirectExecutionSetEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateIndirectExecutionSetEXT);
     if (strcmp(pName, "vkDestroyIndirectExecutionSetEXT") == 0 && (!device || device_dispatch_table(device)->DestroyIndirectExecutionSetEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyIndirectExecutionSetEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyIndirectExecutionSetEXT);
     if (strcmp(pName, "vkUpdateIndirectExecutionSetPipelineEXT") == 0 && (!device || device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateIndirectExecutionSetPipelineEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateIndirectExecutionSetPipelineEXT);
     if (strcmp(pName, "vkUpdateIndirectExecutionSetShaderEXT") == 0 && (!device || device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateIndirectExecutionSetShaderEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkUpdateIndirectExecutionSetShaderEXT);
 #if defined(VK_USE_PLATFORM_METAL_EXT)
     if (strcmp(pName, "vkGetMemoryMetalHandleEXT") == 0 && (!device || device_dispatch_table(device)->GetMemoryMetalHandleEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryMetalHandleEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryMetalHandleEXT);
     if (strcmp(pName, "vkGetMemoryMetalHandlePropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryMetalHandlePropertiesEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetMemoryMetalHandlePropertiesEXT);
 #endif  // VK_USE_PLATFORM_METAL_EXT
     if (strcmp(pName, "vkCmdEndRendering2EXT") == 0 && (!device || device_dispatch_table(device)->CmdEndRendering2EXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRendering2EXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRendering2EXT);
     if (strcmp(pName, "vkCmdBeginCustomResolveEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginCustomResolveEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginCustomResolveEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginCustomResolveEXT);
     if (strcmp(pName, "vkCmdSetComputeOccupancyPriorityNV") == 0 && (!device || device_dispatch_table(device)->CmdSetComputeOccupancyPriorityNV))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetComputeOccupancyPriorityNV<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetComputeOccupancyPriorityNV);
     if (strcmp(pName, "vkCreateAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CreateAccelerationStructureKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateAccelerationStructureKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateAccelerationStructureKHR);
     if (strcmp(pName, "vkDestroyAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->DestroyAccelerationStructureKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyAccelerationStructureKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkDestroyAccelerationStructureKHR);
     if (strcmp(pName, "vkCmdBuildAccelerationStructuresKHR") == 0 && (!device || device_dispatch_table(device)->CmdBuildAccelerationStructuresKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildAccelerationStructuresKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildAccelerationStructuresKHR);
     if (strcmp(pName, "vkCmdBuildAccelerationStructuresIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdBuildAccelerationStructuresIndirectKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildAccelerationStructuresIndirectKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdBuildAccelerationStructuresIndirectKHR);
     if (strcmp(pName, "vkBuildAccelerationStructuresKHR") == 0 && (!device || device_dispatch_table(device)->BuildAccelerationStructuresKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkBuildAccelerationStructuresKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkBuildAccelerationStructuresKHR);
     if (strcmp(pName, "vkCopyAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CopyAccelerationStructureKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyAccelerationStructureKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyAccelerationStructureKHR);
     if (strcmp(pName, "vkCopyAccelerationStructureToMemoryKHR") == 0 && (!device || device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyAccelerationStructureToMemoryKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyAccelerationStructureToMemoryKHR);
     if (strcmp(pName, "vkCopyMemoryToAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToAccelerationStructureKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCopyMemoryToAccelerationStructureKHR);
     if (strcmp(pName, "vkWriteAccelerationStructuresPropertiesKHR") == 0 && (!device || device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteAccelerationStructuresPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkWriteAccelerationStructuresPropertiesKHR);
     if (strcmp(pName, "vkCmdCopyAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyAccelerationStructureKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyAccelerationStructureKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyAccelerationStructureKHR);
     if (strcmp(pName, "vkCmdCopyAccelerationStructureToMemoryKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyAccelerationStructureToMemoryKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyAccelerationStructureToMemoryKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyAccelerationStructureToMemoryKHR);
     if (strcmp(pName, "vkCmdCopyMemoryToAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToAccelerationStructureKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToAccelerationStructureKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyMemoryToAccelerationStructureKHR);
     if (strcmp(pName, "vkGetAccelerationStructureDeviceAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureDeviceAddressKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureDeviceAddressKHR);
     if (strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesKHR") == 0 && (!device || device_dispatch_table(device)->CmdWriteAccelerationStructuresPropertiesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteAccelerationStructuresPropertiesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteAccelerationStructuresPropertiesKHR);
     if (strcmp(pName, "vkGetDeviceAccelerationStructureCompatibilityKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceAccelerationStructureCompatibilityKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceAccelerationStructureCompatibilityKHR);
     if (strcmp(pName, "vkGetAccelerationStructureBuildSizesKHR") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureBuildSizesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetAccelerationStructureBuildSizesKHR);
     if (strcmp(pName, "vkCmdTraceRaysKHR") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysKHR);
     if (strcmp(pName, "vkCreateRayTracingPipelinesKHR") == 0 && (!device || device_dispatch_table(device)->CreateRayTracingPipelinesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRayTracingPipelinesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCreateRayTracingPipelinesKHR);
     if (strcmp(pName, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") == 0 && (!device || device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR);
     if (strcmp(pName, "vkCmdTraceRaysIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysIndirectKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysIndirectKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdTraceRaysIndirectKHR);
     if (strcmp(pName, "vkGetRayTracingShaderGroupStackSizeKHR") == 0 && (!device || device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingShaderGroupStackSizeKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkGetRayTracingShaderGroupStackSizeKHR);
     if (strcmp(pName, "vkCmdSetRayTracingPipelineStackSizeKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetRayTracingPipelineStackSizeKHR))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRayTracingPipelineStackSizeKHR<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetRayTracingPipelineStackSizeKHR);
     if (strcmp(pName, "vkCmdDrawMeshTasksEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksEXT);
     if (strcmp(pName, "vkCmdDrawMeshTasksIndirectEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectEXT);
     if (strcmp(pName, "vkCmdDrawMeshTasksIndirectCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectCountEXT))
-        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectCountEXT<Format>);
+        return reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawMeshTasksIndirectCountEXT);
 
     return nullptr;
 }
diff --git a/layersvt/generated/api_dump_implementation.h b/layersvt/generated/api_dump_implementation.h
index 8ea2576d11..e921d0fb7c 100644
--- a/layersvt/generated/api_dump_implementation.h
+++ b/layersvt/generated/api_dump_implementation.h
@@ -27,47839 +27,45748 @@
 
 //========================== Handle Implementations =========================//
 
-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);
+void dump_VkBuffer(ApiDumpInstance& api_dump, const VkBuffer& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkImage(ApiDumpInstance& api_dump, const VkImage& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), type_name, var_name, indents, address);
 }
 
-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);
+void dump_VkInstance(ApiDumpInstance& api_dump, const VkInstance& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, static_cast<void*>(object), 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);
+void dump_VkPhysicalDevice(ApiDumpInstance& api_dump, const VkPhysicalDevice& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, static_cast<void*>(object), 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);
+void dump_VkDevice(ApiDumpInstance& api_dump, const VkDevice& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, static_cast<void*>(object), 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);
+void dump_VkQueue(ApiDumpInstance& api_dump, const VkQueue& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, static_cast<void*>(object), 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);
+void dump_VkSemaphore(ApiDumpInstance& api_dump, const VkSemaphore& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkCommandBuffer(ApiDumpInstance& api_dump, const VkCommandBuffer& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, static_cast<void*>(object), 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);
+void dump_VkFence(ApiDumpInstance& api_dump, const VkFence& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDeviceMemory(ApiDumpInstance& api_dump, const VkDeviceMemory& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkQueryPool(ApiDumpInstance& api_dump, const VkQueryPool& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkImageView(ApiDumpInstance& api_dump, const VkImageView& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkCommandPool(ApiDumpInstance& api_dump, const VkCommandPool& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkRenderPass(ApiDumpInstance& api_dump, const VkRenderPass& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkFramebuffer(ApiDumpInstance& api_dump, const VkFramebuffer& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkEvent(ApiDumpInstance& api_dump, const VkEvent& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkBufferView(ApiDumpInstance& api_dump, const VkBufferView& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkShaderModule(ApiDumpInstance& api_dump, const VkShaderModule& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkPipelineCache(ApiDumpInstance& api_dump, const VkPipelineCache& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkPipelineLayout(ApiDumpInstance& api_dump, const VkPipelineLayout& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkPipeline(ApiDumpInstance& api_dump, const VkPipeline& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDescriptorSetLayout(ApiDumpInstance& api_dump, const VkDescriptorSetLayout& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkSampler(ApiDumpInstance& api_dump, const VkSampler& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDescriptorSet(ApiDumpInstance& api_dump, const VkDescriptorSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDescriptorPool(ApiDumpInstance& api_dump, const VkDescriptorPool& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDescriptorUpdateTemplate(ApiDumpInstance& api_dump, const VkDescriptorUpdateTemplate& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkSamplerYcbcrConversion(ApiDumpInstance& api_dump, const VkSamplerYcbcrConversion& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkPrivateDataSlot(ApiDumpInstance& api_dump, const VkPrivateDataSlot& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkSurfaceKHR(ApiDumpInstance& api_dump, const VkSurfaceKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkSwapchainKHR(ApiDumpInstance& api_dump, const VkSwapchainKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDisplayKHR(ApiDumpInstance& api_dump, const VkDisplayKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDisplayModeKHR(ApiDumpInstance& api_dump, const VkDisplayModeKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkVideoSessionKHR(ApiDumpInstance& api_dump, const VkVideoSessionKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkVideoSessionParametersKHR(ApiDumpInstance& api_dump, const VkVideoSessionParametersKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDeferredOperationKHR(ApiDumpInstance& api_dump, const VkDeferredOperationKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkPipelineBinaryKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDebugReportCallbackEXT(ApiDumpInstance& api_dump, const VkDebugReportCallbackEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkCuModuleNVX(ApiDumpInstance& api_dump, const VkCuModuleNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkCuFunctionNVX(ApiDumpInstance& api_dump, const VkCuFunctionNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDebugUtilsMessengerEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessengerEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkTensorARM(ApiDumpInstance& api_dump, const VkTensorARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkValidationCacheEXT(ApiDumpInstance& api_dump, const VkValidationCacheEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkAccelerationStructureNV(ApiDumpInstance& api_dump, const VkAccelerationStructureNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkPerformanceConfigurationINTEL(ApiDumpInstance& api_dump, const VkPerformanceConfigurationINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkIndirectCommandsLayoutNV(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkCudaModuleNV(ApiDumpInstance& api_dump, const VkCudaModuleNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkCudaFunctionNV(ApiDumpInstance& api_dump, const VkCudaFunctionNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), type_name, var_name, indents, address);
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
-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);
+void dump_VkAccelerationStructureKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), type_name, var_name, indents, address);
 }
 #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);
+void dump_VkBufferCollectionFUCHSIA(ApiDumpInstance& api_dump, const VkBufferCollectionFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkMicromapEXT(ApiDumpInstance& api_dump, const VkMicromapEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkTensorViewARM(ApiDumpInstance& api_dump, const VkTensorViewARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkOpticalFlowSessionNV(ApiDumpInstance& api_dump, const VkOpticalFlowSessionNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkShaderEXT(ApiDumpInstance& api_dump, const VkShaderEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkDataGraphPipelineSessionARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkExternalComputeQueueNV(ApiDumpInstance& api_dump, const VkExternalComputeQueueNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, static_cast<void*>(object), 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);
+void dump_VkIndirectExecutionSetEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_VkIndirectCommandsLayoutEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_handle(api_dump, TYPE_ERASE_HANDLE(object), 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);
+void dump_StdVideoH264ChromaFormatIdc(ApiDumpInstance& api_dump, const StdVideoH264ChromaFormatIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264ProfileIdc(ApiDumpInstance& api_dump, const StdVideoH264ProfileIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "STD_VIDEO_H264_PROFILE_IDC_HIGH", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264LevelIdc(ApiDumpInstance& api_dump, const StdVideoH264LevelIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264PocType(ApiDumpInstance& api_dump, const StdVideoH264PocType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264AspectRatioIdc(ApiDumpInstance& api_dump, const StdVideoH264AspectRatioIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264WeightedBipredIdc(ApiDumpInstance& api_dump, const StdVideoH264WeightedBipredIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264ModificationOfPicNumsIdc(ApiDumpInstance& api_dump, const StdVideoH264ModificationOfPicNumsIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264MemMgmtControlOp(ApiDumpInstance& api_dump, const StdVideoH264MemMgmtControlOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264CabacInitIdc(ApiDumpInstance& api_dump, const StdVideoH264CabacInitIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264DisableDeblockingFilterIdc(ApiDumpInstance& api_dump, const StdVideoH264DisableDeblockingFilterIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264SliceType(ApiDumpInstance& api_dump, const StdVideoH264SliceType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264PictureType(ApiDumpInstance& api_dump, const StdVideoH264PictureType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264NonVclNaluType(ApiDumpInstance& api_dump, const StdVideoH264NonVclNaluType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoDecodeH264FieldOrderCount(ApiDumpInstance& api_dump, const StdVideoDecodeH264FieldOrderCount object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH265ChromaFormatIdc(ApiDumpInstance& api_dump, const StdVideoH265ChromaFormatIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH265ProfileIdc(ApiDumpInstance& api_dump, const StdVideoH265ProfileIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH265LevelIdc(ApiDumpInstance& api_dump, const StdVideoH265LevelIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH265SliceType(ApiDumpInstance& api_dump, const StdVideoH265SliceType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH265PictureType(ApiDumpInstance& api_dump, const StdVideoH265PictureType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoH265AspectRatioIdc(ApiDumpInstance& api_dump, const StdVideoH265AspectRatioIdc object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1Profile(ApiDumpInstance& api_dump, const StdVideoAV1Profile object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1Level(ApiDumpInstance& api_dump, const StdVideoAV1Level object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1FrameType(ApiDumpInstance& api_dump, const StdVideoAV1FrameType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1ReferenceName(ApiDumpInstance& api_dump, const StdVideoAV1ReferenceName object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1InterpolationFilter(ApiDumpInstance& api_dump, const StdVideoAV1InterpolationFilter object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1TxMode(ApiDumpInstance& api_dump, const StdVideoAV1TxMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1FrameRestorationType(ApiDumpInstance& api_dump, const StdVideoAV1FrameRestorationType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1ColorPrimaries(ApiDumpInstance& api_dump, const StdVideoAV1ColorPrimaries object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1TransferCharacteristics(ApiDumpInstance& api_dump, const StdVideoAV1TransferCharacteristics object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1MatrixCoefficients(ApiDumpInstance& api_dump, const StdVideoAV1MatrixCoefficients object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoAV1ChromaSamplePosition(ApiDumpInstance& api_dump, const StdVideoAV1ChromaSamplePosition object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoVP9Profile(ApiDumpInstance& api_dump, const StdVideoVP9Profile object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoVP9Level(ApiDumpInstance& api_dump, const StdVideoVP9Level object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoVP9FrameType(ApiDumpInstance& api_dump, const StdVideoVP9FrameType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoVP9ReferenceName(ApiDumpInstance& api_dump, const StdVideoVP9ReferenceName object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoVP9InterpolationFilter(ApiDumpInstance& api_dump, const StdVideoVP9InterpolationFilter object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_StdVideoVP9ColorSpace(ApiDumpInstance& api_dump, const StdVideoVP9ColorSpace object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
 //=========================== Enum Implementations ==========================//
 
-template <ApiDumpFormat Format>
-void dump_return_value_VkResult(const VkResult& object, const ApiDumpSettings& settings) {
+void dump_return_value_VkResult(ApiDumpInstance& api_dump, const VkResult& object) {
     switch ((int64_t)object) {
         case VK_SUCCESS:
-            dump_enum<Format>(settings, "VK_SUCCESS", static_cast<int32_t>(object));
+            dump_enum(api_dump, "VK_SUCCESS", static_cast<int32_t>(object));
             break;
         case VK_NOT_READY:
-            dump_enum<Format>(settings, "VK_NOT_READY", static_cast<int32_t>(object));
+            dump_enum(api_dump, "VK_NOT_READY", static_cast<int32_t>(object));
             break;
         case VK_TIMEOUT:
-            dump_enum<Format>(settings, "VK_TIMEOUT", static_cast<int32_t>(object));
+            dump_enum(api_dump, "VK_TIMEOUT", static_cast<int32_t>(object));
             break;
         case VK_EVENT_SET:
-            dump_enum<Format>(settings, "VK_EVENT_SET", static_cast<int32_t>(object));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_EVENT_RESET", static_cast<int32_t>(object));
             break;
         case VK_INCOMPLETE:
-            dump_enum<Format>(settings, "VK_INCOMPLETE", static_cast<int32_t>(object));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum_with_value(api_dump, "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);
+void dump_VkResult(ApiDumpInstance& api_dump, const VkResult object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_return_value_VkResult(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkStructureType(ApiDumpInstance& api_dump, const VkStructureType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO", 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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR", static_cast<uint32_t>(object));
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
-            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV", static_cast<uint32_t>(object));
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV", 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));
+            dump_enum(api_dump, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkImageLayout(ApiDumpInstance& api_dump, const VkImageLayout object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkObjectType(ApiDumpInstance& api_dump, const VkObjectType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkVendorId(ApiDumpInstance& api_dump, const VkVendorId object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_VENDOR_ID_MOBILEYE", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSystemAllocationScope(ApiDumpInstance& api_dump, const VkSystemAllocationScope object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkInternalAllocationType(ApiDumpInstance& api_dump, const VkInternalAllocationType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFormat(ApiDumpInstance& api_dump, const VkFormat object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_FORMAT_R8_BOOL_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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkImageTiling(ApiDumpInstance& api_dump, const VkImageTiling object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkImageType(ApiDumpInstance& api_dump, const VkImageType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_IMAGE_TYPE_3D", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceType(ApiDumpInstance& api_dump, const VkPhysicalDeviceType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkQueryType(ApiDumpInstance& api_dump, const VkQueryType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV", 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSharingMode(ApiDumpInstance& api_dump, const VkSharingMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_SHARING_MODE_CONCURRENT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkComponentSwizzle(ApiDumpInstance& api_dump, const VkComponentSwizzle object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_COMPONENT_SWIZZLE_A", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkImageViewType(ApiDumpInstance& api_dump, const VkImageViewType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCommandBufferLevel(ApiDumpInstance& api_dump, const VkCommandBufferLevel object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkIndexType(ApiDumpInstance& api_dump, const VkIndexType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPipelineCacheHeaderVersion(ApiDumpInstance& api_dump, const VkPipelineCacheHeaderVersion object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBorderColor(ApiDumpInstance& api_dump, const VkBorderColor object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFilter(ApiDumpInstance& api_dump, const VkFilter object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_FILTER_CUBIC_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSamplerAddressMode(ApiDumpInstance& api_dump, const VkSamplerAddressMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSamplerMipmapMode(ApiDumpInstance& api_dump, const VkSamplerMipmapMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCompareOp(ApiDumpInstance& api_dump, const VkCompareOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_COMPARE_OP_ALWAYS", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDescriptorType(ApiDumpInstance& api_dump, const VkDescriptorType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPipelineBindPoint(ApiDumpInstance& api_dump, const VkPipelineBindPoint object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBlendFactor(ApiDumpInstance& api_dump, const VkBlendFactor object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBlendOp(ApiDumpInstance& api_dump, const VkBlendOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDynamicState(ApiDumpInstance& api_dump, const VkDynamicState object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFrontFace(ApiDumpInstance& api_dump, const VkFrontFace object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_FRONT_FACE_CLOCKWISE", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkVertexInputRate(ApiDumpInstance& api_dump, const VkVertexInputRate object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPrimitiveTopology(ApiDumpInstance& api_dump, const VkPrimitiveTopology object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPolygonMode(ApiDumpInstance& api_dump, const VkPolygonMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkStencilOp(ApiDumpInstance& api_dump, const VkStencilOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkLogicOp(ApiDumpInstance& api_dump, const VkLogicOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_LOGIC_OP_SET", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAttachmentLoadOp(ApiDumpInstance& api_dump, const VkAttachmentLoadOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAttachmentStoreOp(ApiDumpInstance& api_dump, const VkAttachmentStoreOp object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSubpassContents(ApiDumpInstance& api_dump, const VkSubpassContents object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDescriptorUpdateTemplateType(ApiDumpInstance& api_dump, const VkDescriptorUpdateTemplateType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSamplerYcbcrModelConversion(ApiDumpInstance& api_dump, const VkSamplerYcbcrModelConversion object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSamplerYcbcrRange(ApiDumpInstance& api_dump, const VkSamplerYcbcrRange object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkChromaLocation(ApiDumpInstance& api_dump, const VkChromaLocation object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_CHROMA_LOCATION_MIDPOINT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPointClippingBehavior(ApiDumpInstance& api_dump, const VkPointClippingBehavior object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkTessellationDomainOrigin(ApiDumpInstance& api_dump, const VkTessellationDomainOrigin object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDriverId(ApiDumpInstance& api_dump, const VkDriverId object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_DRIVER_ID_MESA_KOSMICKRISP", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkShaderFloatControlsIndependence(ApiDumpInstance& api_dump, const VkShaderFloatControlsIndependence object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSemaphoreType(ApiDumpInstance& api_dump, const VkSemaphoreType object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_SEMAPHORE_TYPE_TIMELINE", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSamplerReductionMode(ApiDumpInstance& api_dump, const VkSamplerReductionMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPipelineRobustnessBufferBehavior(ApiDumpInstance& api_dump, const VkPipelineRobustnessBufferBehavior object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPipelineRobustnessImageBehavior(ApiDumpInstance& api_dump, const VkPipelineRobustnessImageBehavior object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkQueueGlobalPriority(ApiDumpInstance& api_dump, const VkQueueGlobalPriority object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkLineRasterizationMode(ApiDumpInstance& api_dump, const VkLineRasterizationMode object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPresentModeKHR(ApiDumpInstance& api_dump, const VkPresentModeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkColorSpaceKHR(ApiDumpInstance& api_dump, const VkColorSpaceKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkQueryResultStatusKHR(ApiDumpInstance& api_dump, const VkQueryResultStatusKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<int32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceCounterUnitKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterUnitKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceCounterScopeKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterScopeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceCounterStorageKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterStorageKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFragmentShadingRateCombinerOpKHR(ApiDumpInstance& api_dump, const VkFragmentShadingRateCombinerOpKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPipelineExecutableStatisticFormatKHR(ApiDumpInstance& api_dump, const VkPipelineExecutableStatisticFormatKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkVideoEncodeTuningModeKHR(ApiDumpInstance& api_dump, const VkVideoEncodeTuningModeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkComponentTypeKHR(ApiDumpInstance& api_dump, const VkComponentTypeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkScopeKHR(ApiDumpInstance& api_dump, const VkScopeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkVideoEncodeAV1PredictionModeKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1PredictionModeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkVideoEncodeAV1RateControlGroupKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1RateControlGroupKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkTimeDomainKHR(ApiDumpInstance& api_dump, const VkTimeDomainKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceLayeredApiKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceLayeredApiKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDefaultVertexAttributeValueKHR(ApiDumpInstance& api_dump, const VkDefaultVertexAttributeValueKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDebugReportObjectTypeEXT(ApiDumpInstance& api_dump, const VkDebugReportObjectTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkRasterizationOrderAMD(ApiDumpInstance& api_dump, const VkRasterizationOrderAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkShaderInfoTypeAMD(ApiDumpInstance& api_dump, const VkShaderInfoTypeAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkValidationCheckEXT(ApiDumpInstance& api_dump, const VkValidationCheckEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDisplayPowerStateEXT(ApiDumpInstance& api_dump, const VkDisplayPowerStateEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDeviceEventTypeEXT(ApiDumpInstance& api_dump, const VkDeviceEventTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDisplayEventTypeEXT(ApiDumpInstance& api_dump, const VkDisplayEventTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkViewportCoordinateSwizzleNV(ApiDumpInstance& api_dump, const VkViewportCoordinateSwizzleNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDiscardRectangleModeEXT(ApiDumpInstance& api_dump, const VkDiscardRectangleModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkConservativeRasterizationModeEXT(ApiDumpInstance& api_dump, const VkConservativeRasterizationModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDescriptorMappingSourceEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBlendOverlapEXT(ApiDumpInstance& api_dump, const VkBlendOverlapEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCoverageModulationModeNV(ApiDumpInstance& api_dump, const VkCoverageModulationModeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkValidationCacheHeaderVersionEXT(ApiDumpInstance& api_dump, const VkValidationCacheHeaderVersionEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkShadingRatePaletteEntryNV(ApiDumpInstance& api_dump, const VkShadingRatePaletteEntryNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCoarseSampleOrderTypeNV(ApiDumpInstance& api_dump, const VkCoarseSampleOrderTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkRayTracingShaderGroupTypeKHR(ApiDumpInstance& api_dump, const VkRayTracingShaderGroupTypeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkGeometryTypeKHR(ApiDumpInstance& api_dump, const VkGeometryTypeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX", 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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAccelerationStructureTypeKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureTypeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCopyAccelerationStructureModeKHR(ApiDumpInstance& api_dump, const VkCopyAccelerationStructureModeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAccelerationStructureMemoryRequirementsTypeNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMemoryRequirementsTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkMemoryOverallocationBehaviorAMD(ApiDumpInstance& api_dump, const VkMemoryOverallocationBehaviorAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceConfigurationTypeINTEL(ApiDumpInstance& api_dump, const VkPerformanceConfigurationTypeINTEL object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkQueryPoolSamplingModeINTEL(ApiDumpInstance& api_dump, const VkQueryPoolSamplingModeINTEL object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceOverrideTypeINTEL(ApiDumpInstance& api_dump, const VkPerformanceOverrideTypeINTEL object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceParameterTypeINTEL(ApiDumpInstance& api_dump, const VkPerformanceParameterTypeINTEL object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceValueTypeINTEL(ApiDumpInstance& api_dump, const VkPerformanceValueTypeINTEL object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkValidationFeatureEnableEXT(ApiDumpInstance& api_dump, const VkValidationFeatureEnableEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkValidationFeatureDisableEXT(ApiDumpInstance& api_dump, const VkValidationFeatureDisableEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCoverageReductionModeNV(ApiDumpInstance& api_dump, const VkCoverageReductionModeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkProvokingVertexModeEXT(ApiDumpInstance& api_dump, const VkProvokingVertexModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFullScreenExclusiveEXT(ApiDumpInstance& api_dump, const VkFullScreenExclusiveEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkIndirectCommandsTokenTypeNV(ApiDumpInstance& api_dump, const VkIndirectCommandsTokenTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDepthBiasRepresentationEXT(ApiDumpInstance& api_dump, const VkDepthBiasRepresentationEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDeviceMemoryReportEventTypeEXT(ApiDumpInstance& api_dump, const VkDeviceMemoryReportEventTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFragmentShadingRateTypeNV(ApiDumpInstance& api_dump, const VkFragmentShadingRateTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkFragmentShadingRateNV(ApiDumpInstance& api_dump, const VkFragmentShadingRateNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAccelerationStructureMotionInstanceTypeNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMotionInstanceTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
-template <ApiDumpFormat Format>
-void dump_VkDeviceFaultAddressTypeEXT(const VkDeviceFaultAddressTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
+void dump_VkDeviceFaultAddressTypeEXT(ApiDumpInstance& api_dump, const VkDeviceFaultAddressTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
     switch ((int64_t)object) {
         case VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT", static_cast<uint32_t>(object));
             break;
         case VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT", static_cast<uint32_t>(object));
             break;
         case VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT", static_cast<uint32_t>(object));
             break;
         case VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT", static_cast<uint32_t>(object));
             break;
         case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT", static_cast<uint32_t>(object));
             break;
         case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT", static_cast<uint32_t>(object));
             break;
         case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
-template <ApiDumpFormat Format>
-void dump_VkDeviceFaultVendorBinaryHeaderVersionEXT(const VkDeviceFaultVendorBinaryHeaderVersionEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
+void dump_VkDeviceFaultVendorBinaryHeaderVersionEXT(ApiDumpInstance& api_dump, const VkDeviceFaultVendorBinaryHeaderVersionEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
     switch ((int64_t)object) {
         case VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT:
-            dump_enum<Format>(settings, "VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDeviceAddressBindingTypeEXT(ApiDumpInstance& api_dump, const VkDeviceAddressBindingTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkMicromapTypeEXT(ApiDumpInstance& api_dump, const VkMicromapTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBuildMicromapModeEXT(ApiDumpInstance& api_dump, const VkBuildMicromapModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCopyMicromapModeEXT(ApiDumpInstance& api_dump, const VkCopyMicromapModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
-template <ApiDumpFormat Format>
-void dump_VkOpacityMicromapFormatEXT(const VkOpacityMicromapFormatEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
+void dump_VkOpacityMicromapFormatEXT(ApiDumpInstance& api_dump, const VkOpacityMicromapFormatEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
     switch ((int64_t)object) {
         case VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT:
-            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT", static_cast<uint32_t>(object));
             break;
         case VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT:
-            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
-template <ApiDumpFormat Format>
-void dump_VkOpacityMicromapSpecialIndexEXT(const VkOpacityMicromapSpecialIndexEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
+void dump_VkOpacityMicromapSpecialIndexEXT(ApiDumpInstance& api_dump, const VkOpacityMicromapSpecialIndexEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
     switch ((int64_t)object) {
         case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT:
-            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT", static_cast<uint32_t>(object));
             break;
         case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT:
-            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT", static_cast<uint32_t>(object));
             break;
         case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT:
-            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT", static_cast<uint32_t>(object));
             break;
         case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT:
-            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT", static_cast<uint32_t>(object));
+            dump_enum(api_dump, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT", 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAccelerationStructureCompatibilityKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureCompatibilityKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAccelerationStructureBuildTypeKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureBuildTypeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDisplacementMicromapFormatNV(ApiDumpInstance& api_dump, const VkDisplacementMicromapFormatNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkRayTracingLssIndexingModeNV(ApiDumpInstance& api_dump, const VkRayTracingLssIndexingModeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkRayTracingLssPrimitiveEndCapsModeNV(ApiDumpInstance& api_dump, const VkRayTracingLssPrimitiveEndCapsModeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkSubpassMergeStatusEXT(ApiDumpInstance& api_dump, const VkSubpassMergeStatusEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDirectDriverLoadingModeLUNARG(ApiDumpInstance& api_dump, const VkDirectDriverLoadingModeLUNARG object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkTensorTilingARM(ApiDumpInstance& api_dump, const VkTensorTilingARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_TENSOR_TILING_LINEAR_ARM", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkOpticalFlowPerformanceLevelNV(ApiDumpInstance& api_dump, const VkOpticalFlowPerformanceLevelNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkOpticalFlowSessionBindingPointNV(ApiDumpInstance& api_dump, const VkOpticalFlowSessionBindingPointNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAntiLagModeAMD(ApiDumpInstance& api_dump, const VkAntiLagModeAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkAntiLagStageAMD(ApiDumpInstance& api_dump, const VkAntiLagStageAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCompressedTriangleFormatAMDX(ApiDumpInstance& api_dump, const VkCompressedTriangleFormatAMDX object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkShaderCodeTypeEXT(ApiDumpInstance& api_dump, const VkShaderCodeTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDepthClampModeEXT(ApiDumpInstance& api_dump, const VkDepthClampModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkRayTracingInvocationReorderModeEXT(ApiDumpInstance& api_dump, const VkRayTracingInvocationReorderModeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCooperativeVectorMatrixLayoutNV(ApiDumpInstance& api_dump, const VkCooperativeVectorMatrixLayoutNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkLayerSettingTypeEXT(ApiDumpInstance& api_dump, const VkLayerSettingTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkLatencyMarkerNV(ApiDumpInstance& api_dump, const VkLatencyMarkerNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkOutOfBandQueueTypeNV(ApiDumpInstance& api_dump, const VkOutOfBandQueueTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDataGraphPipelineSessionBindPointARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionBindPointARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDataGraphPipelineSessionBindPointTypeARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionBindPointTypeARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDataGraphPipelinePropertyARM(ApiDumpInstance& api_dump, const VkDataGraphPipelinePropertyARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDataGraphProcessingEngineTypeARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceDataGraphOperationTypeARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDataGraphOperationTypeARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM", static_cast<uint32_t>(object));
             break;
         default:
-            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
+            dump_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBlockMatchWindowCompareModeQCOM(ApiDumpInstance& api_dump, const VkBlockMatchWindowCompareModeQCOM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkCubicFilterWeightsQCOM(ApiDumpInstance& api_dump, const VkCubicFilterWeightsQCOM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkLayeredDriverUnderlyingApiMSFT(ApiDumpInstance& api_dump, const VkLayeredDriverUnderlyingApiMSFT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDisplaySurfaceStereoTypeNV(ApiDumpInstance& api_dump, const VkDisplaySurfaceStereoTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkClusterAccelerationStructureTypeNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkClusterAccelerationStructureOpTypeNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureOpTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkClusterAccelerationStructureOpModeNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureOpModeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkPartitionedAccelerationStructureOpTypeNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureOpTypeNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkIndirectExecutionSetInfoTypeEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetInfoTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkIndirectCommandsTokenTypeEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsTokenTypeEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkDataGraphModelCacheTypeQCOM(ApiDumpInstance& api_dump, const VkDataGraphModelCacheTypeQCOM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkBuildAccelerationStructureModeKHR(ApiDumpInstance& api_dump, const VkBuildAccelerationStructureModeKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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);
+void dump_VkShaderGroupShaderKHR(ApiDumpInstance& api_dump, const VkShaderGroupShaderKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, 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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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));
+            dump_enum(api_dump, "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_enum_with_value(api_dump, "UNKNOWN", static_cast<uint32_t>(object));
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
 //========================= Bitmask Implementations =========================//
 
-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;
+void dump_VkAccessFlagBits(ApiDumpInstance& api_dump, const VkAccessFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_WRITE_BIT";
         is_first = false;
     }
     if (object == VK_ACCESS_NONE) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_NONE";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageAspectFlagBits(ApiDumpInstance& api_dump, const VkImageAspectFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_IMAGE_ASPECT_COLOR_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_COLOR_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
-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;
+void dump_VkFormatFeatureFlagBits(ApiDumpInstance& api_dump, const VkFormatFeatureFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageCreateFlagBits(ApiDumpInstance& api_dump, const VkImageCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSampleCountFlagBits(ApiDumpInstance& api_dump, const VkSampleCountFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_SAMPLE_COUNT_1_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_1_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageUsageFlagBits(ApiDumpInstance& api_dump, const VkImageUsageFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkInstanceCreateFlagBits(ApiDumpInstance& api_dump, const VkInstanceCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMemoryHeapFlagBits(ApiDumpInstance& api_dump, const VkMemoryHeapFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMemoryPropertyFlagBits(ApiDumpInstance& api_dump, const VkMemoryPropertyFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkQueueFlagBits(ApiDumpInstance& api_dump, const VkQueueFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_QUEUE_GRAPHICS_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_GRAPHICS_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDeviceQueueCreateFlagBits(ApiDumpInstance& api_dump, const VkDeviceQueueCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineStageFlagBits(ApiDumpInstance& api_dump, const VkPipelineStageFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMemoryMapFlagBits(ApiDumpInstance& api_dump, const VkMemoryMapFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSparseMemoryBindFlagBits(ApiDumpInstance& api_dump, const VkSparseMemoryBindFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSparseImageFormatFlagBits(ApiDumpInstance& api_dump, const VkSparseImageFormatFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkFenceCreateFlagBits(ApiDumpInstance& api_dump, const VkFenceCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_FENCE_CREATE_SIGNALED_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_CREATE_SIGNALED_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkQueryPoolCreateFlagBits(ApiDumpInstance& api_dump, const VkQueryPoolCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkQueryPipelineStatisticFlagBits(ApiDumpInstance& api_dump, const VkQueryPipelineStatisticFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkQueryResultFlagBits(ApiDumpInstance& api_dump, const VkQueryResultFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_QUERY_RESULT_64_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_64_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkBufferCreateFlagBits(ApiDumpInstance& api_dump, const VkBufferCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkBufferUsageFlagBits(ApiDumpInstance& api_dump, const VkBufferUsageFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageViewCreateFlagBits(ApiDumpInstance& api_dump, const VkImageViewCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDependencyFlagBits(ApiDumpInstance& api_dump, const VkDependencyFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_DEPENDENCY_BY_REGION_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_BY_REGION_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkCommandPoolCreateFlagBits(ApiDumpInstance& api_dump, const VkCommandPoolCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkCommandPoolResetFlagBits(ApiDumpInstance& api_dump, const VkCommandPoolResetFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkCommandBufferUsageFlagBits(ApiDumpInstance& api_dump, const VkCommandBufferUsageFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkQueryControlFlagBits(ApiDumpInstance& api_dump, const VkQueryControlFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_QUERY_CONTROL_PRECISE_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_CONTROL_PRECISE_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkCommandBufferResetFlagBits(ApiDumpInstance& api_dump, const VkCommandBufferResetFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkEventCreateFlagBits(ApiDumpInstance& api_dump, const VkEventCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineCacheCreateFlagBits(ApiDumpInstance& api_dump, const VkPipelineCacheCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineCreateFlagBits(ApiDumpInstance& api_dump, const VkPipelineCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
         is_first = false;
     }
     if (object & VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineShaderStageCreateFlagBits(ApiDumpInstance& api_dump, const VkPipelineShaderStageCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkShaderStageFlagBits(ApiDumpInstance& api_dump, const VkShaderStageFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_SHADER_STAGE_VERTEX_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_VERTEX_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineLayoutCreateFlagBits(ApiDumpInstance& api_dump, const VkPipelineLayoutCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSamplerCreateFlagBits(ApiDumpInstance& api_dump, const VkSamplerCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDescriptorPoolCreateFlagBits(ApiDumpInstance& api_dump, const VkDescriptorPoolCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDescriptorSetLayoutCreateFlagBits(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkColorComponentFlagBits(ApiDumpInstance& api_dump, const VkColorComponentFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_COLOR_COMPONENT_R_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_R_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkCullModeFlagBits(ApiDumpInstance& api_dump, const VkCullModeFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object == VK_CULL_MODE_NONE) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_NONE";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineDepthStencilStateCreateFlagBits(ApiDumpInstance& api_dump, const VkPipelineDepthStencilStateCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineColorBlendStateCreateFlagBits(ApiDumpInstance& api_dump, const VkPipelineColorBlendStateCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkAttachmentDescriptionFlagBits(ApiDumpInstance& api_dump, const VkAttachmentDescriptionFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkFramebufferCreateFlagBits(ApiDumpInstance& api_dump, const VkFramebufferCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkRenderPassCreateFlagBits(ApiDumpInstance& api_dump, const VkRenderPassCreateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSubpassDescriptionFlagBits(ApiDumpInstance& api_dump, const VkSubpassDescriptionFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkStencilFaceFlagBits(ApiDumpInstance& api_dump, const VkStencilFaceFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_STENCIL_FACE_FRONT_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPeerMemoryFeatureFlagBits(ApiDumpInstance& api_dump, const VkPeerMemoryFeatureFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMemoryAllocateFlagBits(ApiDumpInstance& api_dump, const VkMemoryAllocateFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalMemoryHandleTypeFlagBits(ApiDumpInstance& api_dump, const VkExternalMemoryHandleTypeFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalMemoryFeatureFlagBits(ApiDumpInstance& api_dump, const VkExternalMemoryFeatureFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalFenceHandleTypeFlagBits(ApiDumpInstance& api_dump, const VkExternalFenceHandleTypeFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalFenceFeatureFlagBits(ApiDumpInstance& api_dump, const VkExternalFenceFeatureFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkFenceImportFlagBits(ApiDumpInstance& api_dump, const VkFenceImportFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_FENCE_IMPORT_TEMPORARY_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_IMPORT_TEMPORARY_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSemaphoreImportFlagBits(ApiDumpInstance& api_dump, const VkSemaphoreImportFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalSemaphoreHandleTypeFlagBits(ApiDumpInstance& api_dump, const VkExternalSemaphoreHandleTypeFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalSemaphoreFeatureFlagBits(ApiDumpInstance& api_dump, const VkExternalSemaphoreFeatureFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSubgroupFeatureFlagBits(ApiDumpInstance& api_dump, const VkSubgroupFeatureFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_SUBGROUP_FEATURE_BASIC_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BASIC_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkResolveModeFlagBits(ApiDumpInstance& api_dump, const VkResolveModeFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object == VK_RESOLVE_MODE_NONE) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_NONE";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSemaphoreWaitFlagBits(ApiDumpInstance& api_dump, const VkSemaphoreWaitFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_SEMAPHORE_WAIT_ANY_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_WAIT_ANY_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDescriptorBindingFlagBits(ApiDumpInstance& api_dump, const VkDescriptorBindingFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkToolPurposeFlagBits(ApiDumpInstance& api_dump, const VkToolPurposeFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_TOOL_PURPOSE_VALIDATION_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_VALIDATION_BIT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineStageFlagBits2(ApiDumpInstance& api_dump, const VkPipelineStageFlagBits2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object == VK_PIPELINE_STAGE_2_NONE) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_NONE";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkAccessFlagBits2(ApiDumpInstance& api_dump, const VkAccessFlagBits2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object == VK_ACCESS_2_NONE) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_NONE";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSubmitFlagBits(ApiDumpInstance& api_dump, const VkSubmitFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_SUBMIT_PROTECTED_BIT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBMIT_PROTECTED_BIT";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkFormatFeatureFlagBits2(ApiDumpInstance& api_dump, const VkFormatFeatureFlagBits2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
         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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
         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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineCreationFeedbackFlagBits(ApiDumpInstance& api_dump, const VkPipelineCreationFeedbackFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkRenderingFlagBits(ApiDumpInstance& api_dump, const VkRenderingFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMemoryUnmapFlagBits(ApiDumpInstance& api_dump, const VkMemoryUnmapFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkBufferUsageFlagBits2(ApiDumpInstance& api_dump, const VkBufferUsageFlagBits2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkHostImageCopyFlagBits(ApiDumpInstance& api_dump, const VkHostImageCopyFlagBits object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineCreateFlagBits2(ApiDumpInstance& api_dump, const VkPipelineCreateFlagBits2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
         is_first = false;
     }
     if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE";
         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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSurfaceTransformFlagBitsKHR(ApiDumpInstance& api_dump, const VkSurfaceTransformFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkCompositeAlphaFlagBitsKHR(ApiDumpInstance& api_dump, const VkCompositeAlphaFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSwapchainCreateFlagBitsKHR(ApiDumpInstance& api_dump, const VkSwapchainCreateFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDeviceGroupPresentModeFlagBitsKHR(ApiDumpInstance& api_dump, const VkDeviceGroupPresentModeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDisplayPlaneAlphaFlagBitsKHR(ApiDumpInstance& api_dump, const VkDisplayPlaneAlphaFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoCodecOperationFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoCodecOperationFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoChromaSubsamplingFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoChromaSubsamplingFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoComponentBitDepthFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoComponentBitDepthFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoCapabilityFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoCapabilityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoSessionCreateFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoSessionCreateFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoSessionParametersCreateFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoSessionParametersCreateFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoCodingControlFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoCodingControlFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoDecodeCapabilityFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeCapabilityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoDecodeUsageFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeUsageFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH264CapabilityFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264CapabilityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH264StdFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264StdFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH264RateControlFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264RateControlFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH265CapabilityFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265CapabilityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH265StdFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265StdFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH265CtbSizeFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265CtbSizeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeH265RateControlFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265RateControlFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264PictureLayoutFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPerformanceCounterDescriptionFlagBitsKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterDescriptionFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkAcquireProfilingLockFlagBitsKHR(ApiDumpInstance& api_dump, const VkAcquireProfilingLockFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeCapabilityFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeCapabilityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeRateControlModeFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeRateControlModeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeFeedbackFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeFeedbackFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeUsageFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeUsageFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeContentFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeContentFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPresentScalingFlagBitsKHR(ApiDumpInstance& api_dump, const VkPresentScalingFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPresentGravityFlagBitsKHR(ApiDumpInstance& api_dump, const VkPresentGravityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeAV1CapabilityFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1CapabilityFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeAV1StdFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1StdFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1SuperblockSizeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeAV1RateControlFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1RateControlFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkAddressCopyFlagBitsKHR(ApiDumpInstance& api_dump, const VkAddressCopyFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeIntraRefreshModeFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkAccessFlagBits3KHR(ApiDumpInstance& api_dump, const VkAccessFlagBits3KHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object == VK_ACCESS_3_NONE_KHR) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_3_NONE_KHR";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkRenderingAttachmentFlagBitsKHR(ApiDumpInstance& api_dump, const VkRenderingAttachmentFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkResolveImageFlagBitsKHR(ApiDumpInstance& api_dump, const VkResolveImageFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDebugReportFlagBitsEXT(ApiDumpInstance& api_dump, const VkDebugReportFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalMemoryHandleTypeFlagBitsNV(ApiDumpInstance& api_dump, const VkExternalMemoryHandleTypeFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExternalMemoryFeatureFlagBitsNV(ApiDumpInstance& api_dump, const VkExternalMemoryFeatureFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkConditionalRenderingFlagBitsEXT(ApiDumpInstance& api_dump, const VkConditionalRenderingFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSurfaceCounterFlagBitsEXT(ApiDumpInstance& api_dump, const VkSurfaceCounterFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDebugUtilsMessageSeverityFlagBitsEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessageSeverityFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDebugUtilsMessageTypeFlagBitsEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessageTypeFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkTensorViewCreateFlagBitsARM(ApiDumpInstance& api_dump, const VkTensorViewCreateFlagBitsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkSpirvResourceTypeFlagBitsEXT(ApiDumpInstance& api_dump, const VkSpirvResourceTypeFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkGeometryFlagBitsKHR(ApiDumpInstance& api_dump, const VkGeometryFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object & VK_GEOMETRY_OPAQUE_BIT_KHR) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_OPAQUE_BIT_KHR";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkGeometryInstanceFlagBitsKHR(ApiDumpInstance& api_dump, const VkGeometryInstanceFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT";
         is_first = false;
     }
     if (object & VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkBuildAccelerationStructureFlagBitsKHR(ApiDumpInstance& api_dump, const VkBuildAccelerationStructureFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
         is_first = false;
     }
     if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT";
         is_first = false;
     }
     if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT";
         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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPipelineCompilerControlFlagBitsAMD(ApiDumpInstance& api_dump, const VkPipelineCompilerControlFlagBitsAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPresentStageFlagBitsEXT(ApiDumpInstance& api_dump, const VkPresentStageFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPastPresentationTimingFlagBitsEXT(ApiDumpInstance& api_dump, const VkPastPresentationTimingFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPresentTimingInfoFlagBitsEXT(ApiDumpInstance& api_dump, const VkPresentTimingInfoFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkShaderCorePropertiesFlagBitsAMD(ApiDumpInstance& api_dump, const VkShaderCorePropertiesFlagBitsAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkIndirectStateFlagBitsNV(ApiDumpInstance& api_dump, const VkIndirectStateFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkIndirectCommandsLayoutUsageFlagBitsNV(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutUsageFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDeviceDiagnosticsConfigFlagBitsNV(ApiDumpInstance& api_dump, const VkDeviceDiagnosticsConfigFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkTileShadingRenderPassFlagBitsQCOM(ApiDumpInstance& api_dump, const VkTileShadingRenderPassFlagBitsQCOM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkExportMetalObjectTypeFlagBitsEXT(ApiDumpInstance& api_dump, const VkExportMetalObjectTypeFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkGraphicsPipelineLibraryFlagBitsEXT(ApiDumpInstance& api_dump, const VkGraphicsPipelineLibraryFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageCompressionFlagBitsEXT(ApiDumpInstance& api_dump, const VkImageCompressionFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
     if (object == VK_IMAGE_COMPRESSION_DEFAULT_EXT) {
-        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DEFAULT_EXT";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageCompressionFixedRateFlagBitsEXT(ApiDumpInstance& api_dump, const VkImageCompressionFixedRateFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDeviceAddressBindingFlagBitsEXT(ApiDumpInstance& api_dump, const VkDeviceAddressBindingFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkImageConstraintsInfoFlagBitsFUCHSIA(ApiDumpInstance& api_dump, const VkImageConstraintsInfoFlagBitsFUCHSIA object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkFrameBoundaryFlagBitsEXT(ApiDumpInstance& api_dump, const VkFrameBoundaryFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbModelConversionFlagBitsVALVE object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbRangeCompressionFlagBitsVALVE object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbChromaOffsetFlagBitsVALVE object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkBuildMicromapFlagBitsEXT(ApiDumpInstance& api_dump, const VkBuildMicromapFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMicromapCreateFlagBitsEXT(ApiDumpInstance& api_dump, const VkMicromapCreateFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPhysicalDeviceSchedulingControlsFlagBitsARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceSchedulingControlsFlagBitsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkMemoryDecompressionMethodFlagBitsEXT(ApiDumpInstance& api_dump, const VkMemoryDecompressionMethodFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkTensorCreateFlagBitsARM(ApiDumpInstance& api_dump, const VkTensorCreateFlagBitsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkTensorUsageFlagBitsARM(ApiDumpInstance& api_dump, const VkTensorUsageFlagBitsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkOpticalFlowGridSizeFlagBitsNV(ApiDumpInstance& api_dump, const VkOpticalFlowGridSizeFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkOpticalFlowUsageFlagBitsNV(ApiDumpInstance& api_dump, const VkOpticalFlowUsageFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkOpticalFlowSessionCreateFlagBitsNV(ApiDumpInstance& api_dump, const VkOpticalFlowSessionCreateFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkOpticalFlowExecuteFlagBitsNV(ApiDumpInstance& api_dump, const VkOpticalFlowExecuteFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkShaderCreateFlagBitsEXT(ApiDumpInstance& api_dump, const VkShaderCreateFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT";
         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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_INDIRECT_BINDABLE_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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDataGraphPipelineSessionCreateFlagBitsARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionCreateFlagBitsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.settings().stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM";
         is_first = false;
     }
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkDataGraphPipelineDispatchFlagBitsARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineDispatchFlagBitsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.settings().stream() << object;
     bool is_first = true;
 
     if (!is_first)
-        settings.stream() << ")";
-    dump_value_end<Format>(settings);
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureAddressResolutionFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkClusterAccelerationStructureClusterFlagBitsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureClusterFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkClusterAccelerationStructureGeometryFlagBitsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureGeometryFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkClusterAccelerationStructureIndexFormatFlagBitsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureIndexFormatFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkPartitionedAccelerationStructureInstanceFlagBitsNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureInstanceFlagBitsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkIndirectCommandsInputModeFlagBitsEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsInputModeFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkIndirectCommandsLayoutUsageFlagBitsEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutUsageFlagBitsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, 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;
+void dump_VkAccelerationStructureCreateFlagBitsKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureCreateFlagBitsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value_start(api_dump);
+    api_dump.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";
+        api_dump.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";
+        api_dump.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";
+        api_dump.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);
+        api_dump.settings().stream() << ")";
+    dump_value_end(api_dump);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 
 //=========================== Flag Implementations ==========================//
 
-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);
+void dump_VkAccessFlags(ApiDumpInstance& api_dump, const VkAccessFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAccessFlagBits(api_dump, static_cast<VkAccessFlagBits>(object), 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);
+void dump_VkImageAspectFlags(ApiDumpInstance& api_dump, const VkImageAspectFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageAspectFlagBits(api_dump, static_cast<VkImageAspectFlagBits>(object), type_name, var_name, indents, address);
 }
-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);
+void dump_VkFormatFeatureFlags(ApiDumpInstance& api_dump, const VkFormatFeatureFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkFormatFeatureFlagBits(api_dump, static_cast<VkFormatFeatureFlagBits>(object), 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);
+void dump_VkImageCreateFlags(ApiDumpInstance& api_dump, const VkImageCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageCreateFlagBits(api_dump, static_cast<VkImageCreateFlagBits>(object), 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);
+void dump_VkSampleCountFlags(ApiDumpInstance& api_dump, const VkSampleCountFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSampleCountFlagBits(api_dump, static_cast<VkSampleCountFlagBits>(object), 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);
+void dump_VkImageUsageFlags(ApiDumpInstance& api_dump, const VkImageUsageFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageUsageFlagBits(api_dump, static_cast<VkImageUsageFlagBits>(object), 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);
+void dump_VkInstanceCreateFlags(ApiDumpInstance& api_dump, const VkInstanceCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkInstanceCreateFlagBits(api_dump, static_cast<VkInstanceCreateFlagBits>(object), 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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);
+void dump_VkMemoryHeapFlags(ApiDumpInstance& api_dump, const VkMemoryHeapFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMemoryHeapFlagBits(api_dump, static_cast<VkMemoryHeapFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkMemoryPropertyFlags(ApiDumpInstance& api_dump, const VkMemoryPropertyFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMemoryPropertyFlagBits(api_dump, static_cast<VkMemoryPropertyFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkQueueFlags(ApiDumpInstance& api_dump, const VkQueueFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkQueueFlagBits(api_dump, static_cast<VkQueueFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkDeviceCreateFlags(ApiDumpInstance& api_dump, const VkDeviceCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkDeviceQueueCreateFlags(ApiDumpInstance& api_dump, const VkDeviceQueueCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDeviceQueueCreateFlagBits(api_dump, static_cast<VkDeviceQueueCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineStageFlags(ApiDumpInstance& api_dump, const VkPipelineStageFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineStageFlagBits(api_dump, static_cast<VkPipelineStageFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkMemoryMapFlags(ApiDumpInstance& api_dump, const VkMemoryMapFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMemoryMapFlagBits(api_dump, static_cast<VkMemoryMapFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSparseMemoryBindFlags(ApiDumpInstance& api_dump, const VkSparseMemoryBindFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSparseMemoryBindFlagBits(api_dump, static_cast<VkSparseMemoryBindFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSparseImageFormatFlags(ApiDumpInstance& api_dump, const VkSparseImageFormatFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSparseImageFormatFlagBits(api_dump, static_cast<VkSparseImageFormatFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkFenceCreateFlags(ApiDumpInstance& api_dump, const VkFenceCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkFenceCreateFlagBits(api_dump, static_cast<VkFenceCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSemaphoreCreateFlags(ApiDumpInstance& api_dump, const VkSemaphoreCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkQueryPoolCreateFlags(ApiDumpInstance& api_dump, const VkQueryPoolCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkQueryPoolCreateFlagBits(api_dump, static_cast<VkQueryPoolCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkQueryPipelineStatisticFlags(ApiDumpInstance& api_dump, const VkQueryPipelineStatisticFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkQueryPipelineStatisticFlagBits(api_dump, static_cast<VkQueryPipelineStatisticFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkQueryResultFlags(ApiDumpInstance& api_dump, const VkQueryResultFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkQueryResultFlagBits(api_dump, static_cast<VkQueryResultFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkBufferCreateFlags(ApiDumpInstance& api_dump, const VkBufferCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkBufferCreateFlagBits(api_dump, static_cast<VkBufferCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkBufferUsageFlags(ApiDumpInstance& api_dump, const VkBufferUsageFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkBufferUsageFlagBits(api_dump, static_cast<VkBufferUsageFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkImageViewCreateFlags(ApiDumpInstance& api_dump, const VkImageViewCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageViewCreateFlagBits(api_dump, static_cast<VkImageViewCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkDependencyFlags(ApiDumpInstance& api_dump, const VkDependencyFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDependencyFlagBits(api_dump, static_cast<VkDependencyFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkCommandPoolCreateFlags(ApiDumpInstance& api_dump, const VkCommandPoolCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkCommandPoolCreateFlagBits(api_dump, static_cast<VkCommandPoolCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkCommandPoolResetFlags(ApiDumpInstance& api_dump, const VkCommandPoolResetFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkCommandPoolResetFlagBits(api_dump, static_cast<VkCommandPoolResetFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkCommandBufferUsageFlags(ApiDumpInstance& api_dump, const VkCommandBufferUsageFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkCommandBufferUsageFlagBits(api_dump, static_cast<VkCommandBufferUsageFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkQueryControlFlags(ApiDumpInstance& api_dump, const VkQueryControlFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkQueryControlFlagBits(api_dump, static_cast<VkQueryControlFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkCommandBufferResetFlags(ApiDumpInstance& api_dump, const VkCommandBufferResetFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkCommandBufferResetFlagBits(api_dump, static_cast<VkCommandBufferResetFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkEventCreateFlags(ApiDumpInstance& api_dump, const VkEventCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkEventCreateFlagBits(api_dump, static_cast<VkEventCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkBufferViewCreateFlags(ApiDumpInstance& api_dump, const VkBufferViewCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkShaderModuleCreateFlags(ApiDumpInstance& api_dump, const VkShaderModuleCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineCacheCreateFlags(ApiDumpInstance& api_dump, const VkPipelineCacheCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineCacheCreateFlagBits(api_dump, static_cast<VkPipelineCacheCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineCreateFlags(ApiDumpInstance& api_dump, const VkPipelineCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineCreateFlagBits(api_dump, static_cast<VkPipelineCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineShaderStageCreateFlags(ApiDumpInstance& api_dump, const VkPipelineShaderStageCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineShaderStageCreateFlagBits(api_dump, static_cast<VkPipelineShaderStageCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineLayoutCreateFlags(ApiDumpInstance& api_dump, const VkPipelineLayoutCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineLayoutCreateFlagBits(api_dump, static_cast<VkPipelineLayoutCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkShaderStageFlags(ApiDumpInstance& api_dump, const VkShaderStageFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkShaderStageFlagBits(api_dump, static_cast<VkShaderStageFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSamplerCreateFlags(ApiDumpInstance& api_dump, const VkSamplerCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSamplerCreateFlagBits(api_dump, static_cast<VkSamplerCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkDescriptorPoolCreateFlags(ApiDumpInstance& api_dump, const VkDescriptorPoolCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDescriptorPoolCreateFlagBits(api_dump, static_cast<VkDescriptorPoolCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkDescriptorPoolResetFlags(ApiDumpInstance& api_dump, const VkDescriptorPoolResetFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkDescriptorSetLayoutCreateFlags(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDescriptorSetLayoutCreateFlagBits(api_dump, static_cast<VkDescriptorSetLayoutCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkColorComponentFlags(ApiDumpInstance& api_dump, const VkColorComponentFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkColorComponentFlagBits(api_dump, static_cast<VkColorComponentFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkCullModeFlags(ApiDumpInstance& api_dump, const VkCullModeFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkCullModeFlagBits(api_dump, static_cast<VkCullModeFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineVertexInputStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineVertexInputStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineInputAssemblyStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineInputAssemblyStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineTessellationStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineTessellationStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineViewportStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineViewportStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineRasterizationStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineRasterizationStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineMultisampleStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineMultisampleStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineDepthStencilStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineDepthStencilStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineDepthStencilStateCreateFlagBits(api_dump, static_cast<VkPipelineDepthStencilStateCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineColorBlendStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineColorBlendStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineColorBlendStateCreateFlagBits(api_dump, static_cast<VkPipelineColorBlendStateCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineDynamicStateCreateFlags(ApiDumpInstance& api_dump, const VkPipelineDynamicStateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkAttachmentDescriptionFlags(ApiDumpInstance& api_dump, const VkAttachmentDescriptionFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAttachmentDescriptionFlagBits(api_dump, static_cast<VkAttachmentDescriptionFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkFramebufferCreateFlags(ApiDumpInstance& api_dump, const VkFramebufferCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkFramebufferCreateFlagBits(api_dump, static_cast<VkFramebufferCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkRenderPassCreateFlags(ApiDumpInstance& api_dump, const VkRenderPassCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkRenderPassCreateFlagBits(api_dump, static_cast<VkRenderPassCreateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSubpassDescriptionFlags(ApiDumpInstance& api_dump, const VkSubpassDescriptionFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSubpassDescriptionFlagBits(api_dump, static_cast<VkSubpassDescriptionFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkStencilFaceFlags(ApiDumpInstance& api_dump, const VkStencilFaceFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkStencilFaceFlagBits(api_dump, static_cast<VkStencilFaceFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPeerMemoryFeatureFlags(ApiDumpInstance& api_dump, const VkPeerMemoryFeatureFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPeerMemoryFeatureFlagBits(api_dump, static_cast<VkPeerMemoryFeatureFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkMemoryAllocateFlags(ApiDumpInstance& api_dump, const VkMemoryAllocateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMemoryAllocateFlagBits(api_dump, static_cast<VkMemoryAllocateFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkCommandPoolTrimFlags(ApiDumpInstance& api_dump, const VkCommandPoolTrimFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkExternalMemoryHandleTypeFlags(ApiDumpInstance& api_dump, const VkExternalMemoryHandleTypeFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, static_cast<VkExternalMemoryHandleTypeFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkExternalMemoryFeatureFlags(ApiDumpInstance& api_dump, const VkExternalMemoryFeatureFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalMemoryFeatureFlagBits(api_dump, static_cast<VkExternalMemoryFeatureFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkExternalFenceHandleTypeFlags(ApiDumpInstance& api_dump, const VkExternalFenceHandleTypeFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalFenceHandleTypeFlagBits(api_dump, static_cast<VkExternalFenceHandleTypeFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkExternalFenceFeatureFlags(ApiDumpInstance& api_dump, const VkExternalFenceFeatureFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalFenceFeatureFlagBits(api_dump, static_cast<VkExternalFenceFeatureFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkFenceImportFlags(ApiDumpInstance& api_dump, const VkFenceImportFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkFenceImportFlagBits(api_dump, static_cast<VkFenceImportFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSemaphoreImportFlags(ApiDumpInstance& api_dump, const VkSemaphoreImportFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSemaphoreImportFlagBits(api_dump, static_cast<VkSemaphoreImportFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkExternalSemaphoreHandleTypeFlags(ApiDumpInstance& api_dump, const VkExternalSemaphoreHandleTypeFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, static_cast<VkExternalSemaphoreHandleTypeFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkExternalSemaphoreFeatureFlags(ApiDumpInstance& api_dump, const VkExternalSemaphoreFeatureFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalSemaphoreFeatureFlagBits(api_dump, static_cast<VkExternalSemaphoreFeatureFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSubgroupFeatureFlags(ApiDumpInstance& api_dump, const VkSubgroupFeatureFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSubgroupFeatureFlagBits(api_dump, static_cast<VkSubgroupFeatureFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkDescriptorUpdateTemplateCreateFlags(ApiDumpInstance& api_dump, const VkDescriptorUpdateTemplateCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkResolveModeFlags(ApiDumpInstance& api_dump, const VkResolveModeFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkResolveModeFlagBits(api_dump, static_cast<VkResolveModeFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkSemaphoreWaitFlags(ApiDumpInstance& api_dump, const VkSemaphoreWaitFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSemaphoreWaitFlagBits(api_dump, static_cast<VkSemaphoreWaitFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkDescriptorBindingFlags(ApiDumpInstance& api_dump, const VkDescriptorBindingFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDescriptorBindingFlagBits(api_dump, static_cast<VkDescriptorBindingFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkToolPurposeFlags(ApiDumpInstance& api_dump, const VkToolPurposeFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkToolPurposeFlagBits(api_dump, static_cast<VkToolPurposeFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPrivateDataSlotCreateFlags(ApiDumpInstance& api_dump, const VkPrivateDataSlotCreateFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineStageFlags2(ApiDumpInstance& api_dump, const VkPipelineStageFlags2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineStageFlagBits2(api_dump, static_cast<VkPipelineStageFlagBits2>(object), type_name, var_name, indents, address);
+}
+void dump_VkAccessFlags2(ApiDumpInstance& api_dump, const VkAccessFlags2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAccessFlagBits2(api_dump, static_cast<VkAccessFlagBits2>(object), type_name, var_name, indents, address);
+}
+void dump_VkSubmitFlags(ApiDumpInstance& api_dump, const VkSubmitFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSubmitFlagBits(api_dump, static_cast<VkSubmitFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkFormatFeatureFlags2(ApiDumpInstance& api_dump, const VkFormatFeatureFlags2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkFormatFeatureFlagBits2(api_dump, static_cast<VkFormatFeatureFlagBits2>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineCreationFeedbackFlags(ApiDumpInstance& api_dump, const VkPipelineCreationFeedbackFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineCreationFeedbackFlagBits(api_dump, static_cast<VkPipelineCreationFeedbackFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkRenderingFlags(ApiDumpInstance& api_dump, const VkRenderingFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkRenderingFlagBits(api_dump, static_cast<VkRenderingFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkMemoryUnmapFlags(ApiDumpInstance& api_dump, const VkMemoryUnmapFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMemoryUnmapFlagBits(api_dump, static_cast<VkMemoryUnmapFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkBufferUsageFlags2(ApiDumpInstance& api_dump, const VkBufferUsageFlags2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkBufferUsageFlagBits2(api_dump, static_cast<VkBufferUsageFlagBits2>(object), type_name, var_name, indents, address);
+}
+void dump_VkHostImageCopyFlags(ApiDumpInstance& api_dump, const VkHostImageCopyFlags object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkHostImageCopyFlagBits(api_dump, static_cast<VkHostImageCopyFlagBits>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineCreateFlags2(ApiDumpInstance& api_dump, const VkPipelineCreateFlags2 object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineCreateFlagBits2(api_dump, static_cast<VkPipelineCreateFlagBits2>(object), type_name, var_name, indents, address);
+}
+void dump_VkCompositeAlphaFlagsKHR(ApiDumpInstance& api_dump, const VkCompositeAlphaFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkCompositeAlphaFlagBitsKHR(api_dump, static_cast<VkCompositeAlphaFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkSurfaceTransformFlagsKHR(ApiDumpInstance& api_dump, const VkSurfaceTransformFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, static_cast<VkSurfaceTransformFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkSwapchainCreateFlagsKHR(ApiDumpInstance& api_dump, const VkSwapchainCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSwapchainCreateFlagBitsKHR(api_dump, static_cast<VkSwapchainCreateFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkDeviceGroupPresentModeFlagsKHR(ApiDumpInstance& api_dump, const VkDeviceGroupPresentModeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDeviceGroupPresentModeFlagBitsKHR(api_dump, static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkDisplayModeCreateFlagsKHR(ApiDumpInstance& api_dump, const VkDisplayModeCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkDisplayPlaneAlphaFlagsKHR(ApiDumpInstance& api_dump, const VkDisplayPlaneAlphaFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDisplayPlaneAlphaFlagBitsKHR(api_dump, static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkDisplaySurfaceCreateFlagsKHR(ApiDumpInstance& api_dump, const VkDisplaySurfaceCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkXlibSurfaceCreateFlagsKHR(ApiDumpInstance& api_dump, const VkXlibSurfaceCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkXcbSurfaceCreateFlagsKHR(ApiDumpInstance& api_dump, const VkXcbSurfaceCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkWaylandSurfaceCreateFlagsKHR(ApiDumpInstance& api_dump, const VkWaylandSurfaceCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkAndroidSurfaceCreateFlagsKHR(ApiDumpInstance& api_dump, const VkAndroidSurfaceCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkWin32SurfaceCreateFlagsKHR(ApiDumpInstance& api_dump, const VkWin32SurfaceCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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_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);
+void dump_VkVideoCodecOperationFlagsKHR(ApiDumpInstance& api_dump, const VkVideoCodecOperationFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoCodecOperationFlagBitsKHR(api_dump, static_cast<VkVideoCodecOperationFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoChromaSubsamplingFlagsKHR(ApiDumpInstance& api_dump, const VkVideoChromaSubsamplingFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoChromaSubsamplingFlagBitsKHR(api_dump, static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoComponentBitDepthFlagsKHR(ApiDumpInstance& api_dump, const VkVideoComponentBitDepthFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoComponentBitDepthFlagBitsKHR(api_dump, static_cast<VkVideoComponentBitDepthFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoCapabilityFlagsKHR(ApiDumpInstance& api_dump, const VkVideoCapabilityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoCapabilityFlagBitsKHR(api_dump, static_cast<VkVideoCapabilityFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoSessionCreateFlagsKHR(ApiDumpInstance& api_dump, const VkVideoSessionCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoSessionCreateFlagBitsKHR(api_dump, static_cast<VkVideoSessionCreateFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoSessionParametersCreateFlagsKHR(ApiDumpInstance& api_dump, const VkVideoSessionParametersCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoSessionParametersCreateFlagBitsKHR(api_dump, static_cast<VkVideoSessionParametersCreateFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoBeginCodingFlagsKHR(ApiDumpInstance& api_dump, const VkVideoBeginCodingFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkVideoEndCodingFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEndCodingFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkVideoCodingControlFlagsKHR(ApiDumpInstance& api_dump, const VkVideoCodingControlFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoCodingControlFlagBitsKHR(api_dump, static_cast<VkVideoCodingControlFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoDecodeCapabilityFlagsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeCapabilityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoDecodeCapabilityFlagBitsKHR(api_dump, static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoDecodeUsageFlagsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeUsageFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoDecodeUsageFlagBitsKHR(api_dump, static_cast<VkVideoDecodeUsageFlagBitsKHR>(object), 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);
+void dump_VkVideoDecodeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
-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);
+void dump_VkVideoEncodeH264CapabilityFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264CapabilityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH264CapabilityFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH264StdFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264StdFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH264StdFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH264StdFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH264RateControlFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264RateControlFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH264RateControlFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH264RateControlFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH265CapabilityFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265CapabilityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH265CapabilityFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH265StdFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265StdFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH265StdFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH265StdFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH265CtbSizeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265CtbSizeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH265CtbSizeFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH265TransformBlockSizeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265TransformBlockSizeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(object), 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);
+void dump_VkVideoEncodeH265RateControlFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265RateControlFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeH265RateControlFlagBitsKHR(api_dump, static_cast<VkVideoEncodeH265RateControlFlagBitsKHR>(object), 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);
+void dump_VkVideoDecodeH264PictureLayoutFlagsKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264PictureLayoutFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(api_dump, static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(object), 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);
+void dump_VkPerformanceCounterDescriptionFlagsKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterDescriptionFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPerformanceCounterDescriptionFlagBitsKHR(api_dump, static_cast<VkPerformanceCounterDescriptionFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkAcquireProfilingLockFlagsKHR(ApiDumpInstance& api_dump, const VkAcquireProfilingLockFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAcquireProfilingLockFlagBitsKHR(api_dump, static_cast<VkAcquireProfilingLockFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeFlagBitsKHR(api_dump, static_cast<VkVideoEncodeFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeCapabilityFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeCapabilityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeCapabilityFlagBitsKHR(api_dump, static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeRateControlModeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeRateControlModeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeRateControlModeFlagBitsKHR(api_dump, static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeFeedbackFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeFeedbackFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeFeedbackFlagBitsKHR(api_dump, static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeUsageFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeUsageFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeUsageFlagBitsKHR(api_dump, static_cast<VkVideoEncodeUsageFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeContentFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeContentFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeContentFlagBitsKHR(api_dump, static_cast<VkVideoEncodeContentFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeRateControlFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeRateControlFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPresentScalingFlagsKHR(ApiDumpInstance& api_dump, const VkPresentScalingFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPresentScalingFlagBitsKHR(api_dump, static_cast<VkPresentScalingFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkPresentGravityFlagsKHR(ApiDumpInstance& api_dump, const VkPresentGravityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPresentGravityFlagBitsKHR(api_dump, static_cast<VkPresentGravityFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeAV1CapabilityFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1CapabilityFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeAV1CapabilityFlagBitsKHR(api_dump, static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeAV1StdFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1StdFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeAV1StdFlagBitsKHR(api_dump, static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1SuperblockSizeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(api_dump, static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeAV1RateControlFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1RateControlFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeAV1RateControlFlagBitsKHR(api_dump, static_cast<VkVideoEncodeAV1RateControlFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkAddressCopyFlagsKHR(ApiDumpInstance& api_dump, const VkAddressCopyFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAddressCopyFlagBitsKHR(api_dump, static_cast<VkAddressCopyFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkVideoEncodeIntraRefreshModeFlagsKHR(ApiDumpInstance& api_dump, const VkVideoEncodeIntraRefreshModeFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(api_dump, static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkAccessFlags3KHR(ApiDumpInstance& api_dump, const VkAccessFlags3KHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAccessFlagBits3KHR(api_dump, static_cast<VkAccessFlagBits3KHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkRenderingAttachmentFlagsKHR(ApiDumpInstance& api_dump, const VkRenderingAttachmentFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkRenderingAttachmentFlagBitsKHR(api_dump, static_cast<VkRenderingAttachmentFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkResolveImageFlagsKHR(ApiDumpInstance& api_dump, const VkResolveImageFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkResolveImageFlagBitsKHR(api_dump, static_cast<VkResolveImageFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkDebugReportFlagsEXT(ApiDumpInstance& api_dump, const VkDebugReportFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDebugReportFlagBitsEXT(api_dump, static_cast<VkDebugReportFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineRasterizationStateStreamCreateFlagsEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationStateStreamCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkStreamDescriptorSurfaceCreateFlagsGGP(ApiDumpInstance& api_dump, const VkStreamDescriptorSurfaceCreateFlagsGGP object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkExternalMemoryHandleTypeFlagsNV(ApiDumpInstance& api_dump, const VkExternalMemoryHandleTypeFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalMemoryHandleTypeFlagBitsNV(api_dump, static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(object), 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);
+void dump_VkExternalMemoryFeatureFlagsNV(ApiDumpInstance& api_dump, const VkExternalMemoryFeatureFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExternalMemoryFeatureFlagBitsNV(api_dump, static_cast<VkExternalMemoryFeatureFlagBitsNV>(object), 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);
+void dump_VkViSurfaceCreateFlagsNN(ApiDumpInstance& api_dump, const VkViSurfaceCreateFlagsNN object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
 #endif  // VK_USE_PLATFORM_VI_NN
-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_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);
+void dump_VkConditionalRenderingFlagsEXT(ApiDumpInstance& api_dump, const VkConditionalRenderingFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkConditionalRenderingFlagBitsEXT(api_dump, static_cast<VkConditionalRenderingFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkSurfaceCounterFlagsEXT(ApiDumpInstance& api_dump, const VkSurfaceCounterFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSurfaceCounterFlagBitsEXT(api_dump, static_cast<VkSurfaceCounterFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineViewportSwizzleStateCreateFlagsNV(ApiDumpInstance& api_dump, const VkPipelineViewportSwizzleStateCreateFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineDiscardRectangleStateCreateFlagsEXT(ApiDumpInstance& api_dump, const VkPipelineDiscardRectangleStateCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineRasterizationConservativeStateCreateFlagsEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationConservativeStateCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationDepthClipStateCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkIOSSurfaceCreateFlagsMVK(ApiDumpInstance& api_dump, const VkIOSSurfaceCreateFlagsMVK object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkMacOSSurfaceCreateFlagsMVK(ApiDumpInstance& api_dump, const VkMacOSSurfaceCreateFlagsMVK object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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_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);
+void dump_VkDebugUtilsMessengerCallbackDataFlagsEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessengerCallbackDataFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkDebugUtilsMessageTypeFlagsEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessageTypeFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDebugUtilsMessageTypeFlagBitsEXT(api_dump, static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkDebugUtilsMessageSeverityFlagsEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessageSeverityFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDebugUtilsMessageSeverityFlagBitsEXT(api_dump, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkDebugUtilsMessengerCreateFlagsEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessengerCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkTensorViewCreateFlagsARM(ApiDumpInstance& api_dump, const VkTensorViewCreateFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkTensorViewCreateFlagBitsARM(api_dump, static_cast<VkTensorViewCreateFlagBitsARM>(object), type_name, var_name, indents, address);
+}
+void dump_VkSpirvResourceTypeFlagsEXT(ApiDumpInstance& api_dump, const VkSpirvResourceTypeFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkSpirvResourceTypeFlagBitsEXT(api_dump, static_cast<VkSpirvResourceTypeFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineCoverageToColorStateCreateFlagsNV(ApiDumpInstance& api_dump, const VkPipelineCoverageToColorStateCreateFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkPipelineCoverageModulationStateCreateFlagsNV(ApiDumpInstance& api_dump, const VkPipelineCoverageModulationStateCreateFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkValidationCacheCreateFlagsEXT(ApiDumpInstance& api_dump, const VkValidationCacheCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkGeometryFlagsKHR(ApiDumpInstance& api_dump, const VkGeometryFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkGeometryFlagBitsKHR(api_dump, static_cast<VkGeometryFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkGeometryInstanceFlagsKHR(ApiDumpInstance& api_dump, const VkGeometryInstanceFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkGeometryInstanceFlagBitsKHR(api_dump, static_cast<VkGeometryInstanceFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkBuildAccelerationStructureFlagsKHR(ApiDumpInstance& api_dump, const VkBuildAccelerationStructureFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkBuildAccelerationStructureFlagBitsKHR(api_dump, static_cast<VkBuildAccelerationStructureFlagBitsKHR>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineCompilerControlFlagsAMD(ApiDumpInstance& api_dump, const VkPipelineCompilerControlFlagsAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPipelineCompilerControlFlagBitsAMD(api_dump, static_cast<VkPipelineCompilerControlFlagBitsAMD>(object), type_name, var_name, indents, address);
+}
+void dump_VkPresentStageFlagsEXT(ApiDumpInstance& api_dump, const VkPresentStageFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPresentStageFlagBitsEXT(api_dump, static_cast<VkPresentStageFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkPastPresentationTimingFlagsEXT(ApiDumpInstance& api_dump, const VkPastPresentationTimingFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPastPresentationTimingFlagBitsEXT(api_dump, static_cast<VkPastPresentationTimingFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkPresentTimingInfoFlagsEXT(ApiDumpInstance& api_dump, const VkPresentTimingInfoFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPresentTimingInfoFlagBitsEXT(api_dump, static_cast<VkPresentTimingInfoFlagBitsEXT>(object), 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);
+void dump_VkImagePipeSurfaceCreateFlagsFUCHSIA(ApiDumpInstance& api_dump, const VkImagePipeSurfaceCreateFlagsFUCHSIA object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkMetalSurfaceCreateFlagsEXT(ApiDumpInstance& api_dump, const VkMetalSurfaceCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkShaderCorePropertiesFlagsAMD(ApiDumpInstance& api_dump, const VkShaderCorePropertiesFlagsAMD object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkShaderCorePropertiesFlagBitsAMD(api_dump, static_cast<VkShaderCorePropertiesFlagBitsAMD>(object), type_name, var_name, indents, address);
+}
+void dump_VkPipelineCoverageReductionStateCreateFlagsNV(ApiDumpInstance& api_dump, const VkPipelineCoverageReductionStateCreateFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkHeadlessSurfaceCreateFlagsEXT(ApiDumpInstance& api_dump, const VkHeadlessSurfaceCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkIndirectStateFlagsNV(ApiDumpInstance& api_dump, const VkIndirectStateFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkIndirectStateFlagBitsNV(api_dump, static_cast<VkIndirectStateFlagBitsNV>(object), type_name, var_name, indents, address);
+}
+void dump_VkIndirectCommandsLayoutUsageFlagsNV(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutUsageFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkIndirectCommandsLayoutUsageFlagBitsNV(api_dump, static_cast<VkIndirectCommandsLayoutUsageFlagBitsNV>(object), type_name, var_name, indents, address);
+}
+void dump_VkDeviceMemoryReportFlagsEXT(ApiDumpInstance& api_dump, const VkDeviceMemoryReportFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkDeviceDiagnosticsConfigFlagsNV(ApiDumpInstance& api_dump, const VkDeviceDiagnosticsConfigFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDeviceDiagnosticsConfigFlagBitsNV(api_dump, static_cast<VkDeviceDiagnosticsConfigFlagBitsNV>(object), type_name, var_name, indents, address);
+}
+void dump_VkTileShadingRenderPassFlagsQCOM(ApiDumpInstance& api_dump, const VkTileShadingRenderPassFlagsQCOM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkTileShadingRenderPassFlagBitsQCOM(api_dump, static_cast<VkTileShadingRenderPassFlagBitsQCOM>(object), 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);
+void dump_VkExportMetalObjectTypeFlagsEXT(ApiDumpInstance& api_dump, const VkExportMetalObjectTypeFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkExportMetalObjectTypeFlagBitsEXT(api_dump, static_cast<VkExportMetalObjectTypeFlagBitsEXT>(object), 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);
+void dump_VkGraphicsPipelineLibraryFlagsEXT(ApiDumpInstance& api_dump, const VkGraphicsPipelineLibraryFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkGraphicsPipelineLibraryFlagBitsEXT(api_dump, static_cast<VkGraphicsPipelineLibraryFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkAccelerationStructureMotionInfoFlagsNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMotionInfoFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkAccelerationStructureMotionInstanceFlagsNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMotionInstanceFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_VkImageCompressionFlagsEXT(ApiDumpInstance& api_dump, const VkImageCompressionFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageCompressionFlagBitsEXT(api_dump, static_cast<VkImageCompressionFlagBitsEXT>(object), type_name, var_name, indents, address);
+}
+void dump_VkImageCompressionFixedRateFlagsEXT(ApiDumpInstance& api_dump, const VkImageCompressionFixedRateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageCompressionFixedRateFlagBitsEXT(api_dump, static_cast<VkImageCompressionFixedRateFlagBitsEXT>(object), 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);
+void dump_VkDirectFBSurfaceCreateFlagsEXT(ApiDumpInstance& api_dump, const VkDirectFBSurfaceCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkDeviceAddressBindingFlagsEXT(ApiDumpInstance& api_dump, const VkDeviceAddressBindingFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDeviceAddressBindingFlagBitsEXT(api_dump, static_cast<VkDeviceAddressBindingFlagBitsEXT>(object), 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);
+void dump_VkImageFormatConstraintsFlagsFUCHSIA(ApiDumpInstance& api_dump, const VkImageFormatConstraintsFlagsFUCHSIA object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkImageConstraintsInfoFlagsFUCHSIA(ApiDumpInstance& api_dump, const VkImageConstraintsInfoFlagsFUCHSIA object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkImageConstraintsInfoFlagBitsFUCHSIA(api_dump, static_cast<VkImageConstraintsInfoFlagBitsFUCHSIA>(object), 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);
+void dump_VkFrameBoundaryFlagsEXT(ApiDumpInstance& api_dump, const VkFrameBoundaryFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkFrameBoundaryFlagBitsEXT(api_dump, static_cast<VkFrameBoundaryFlagBitsEXT>(object), 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);
+void dump_VkScreenSurfaceCreateFlagsQNX(ApiDumpInstance& api_dump, const VkScreenSurfaceCreateFlagsQNX object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkVideoEncodeRgbModelConversionFlagsVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbModelConversionFlagsVALVE object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(api_dump, static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(object), 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);
+void dump_VkVideoEncodeRgbRangeCompressionFlagsVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbRangeCompressionFlagsVALVE object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(api_dump, static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(object), 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);
+void dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbChromaOffsetFlagsVALVE object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(api_dump, static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(object), 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);
+void dump_VkBuildMicromapFlagsEXT(ApiDumpInstance& api_dump, const VkBuildMicromapFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkBuildMicromapFlagBitsEXT(api_dump, static_cast<VkBuildMicromapFlagBitsEXT>(object), 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);
+void dump_VkMicromapCreateFlagsEXT(ApiDumpInstance& api_dump, const VkMicromapCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMicromapCreateFlagBitsEXT(api_dump, static_cast<VkMicromapCreateFlagBitsEXT>(object), 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);
+void dump_VkPhysicalDeviceSchedulingControlsFlagsARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceSchedulingControlsFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPhysicalDeviceSchedulingControlsFlagBitsARM(api_dump, static_cast<VkPhysicalDeviceSchedulingControlsFlagBitsARM>(object), 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);
+void dump_VkMemoryDecompressionMethodFlagsEXT(ApiDumpInstance& api_dump, const VkMemoryDecompressionMethodFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkMemoryDecompressionMethodFlagBitsEXT(api_dump, static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(object), 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);
+void dump_VkDirectDriverLoadingFlagsLUNARG(ApiDumpInstance& api_dump, const VkDirectDriverLoadingFlagsLUNARG object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkTensorCreateFlagsARM(ApiDumpInstance& api_dump, const VkTensorCreateFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkTensorCreateFlagBitsARM(api_dump, static_cast<VkTensorCreateFlagBitsARM>(object), 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);
+void dump_VkTensorUsageFlagsARM(ApiDumpInstance& api_dump, const VkTensorUsageFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkTensorUsageFlagBitsARM(api_dump, static_cast<VkTensorUsageFlagBitsARM>(object), 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);
+void dump_VkOpticalFlowGridSizeFlagsNV(ApiDumpInstance& api_dump, const VkOpticalFlowGridSizeFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkOpticalFlowGridSizeFlagBitsNV(api_dump, static_cast<VkOpticalFlowGridSizeFlagBitsNV>(object), 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);
+void dump_VkOpticalFlowUsageFlagsNV(ApiDumpInstance& api_dump, const VkOpticalFlowUsageFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkOpticalFlowUsageFlagBitsNV(api_dump, static_cast<VkOpticalFlowUsageFlagBitsNV>(object), 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);
+void dump_VkOpticalFlowSessionCreateFlagsNV(ApiDumpInstance& api_dump, const VkOpticalFlowSessionCreateFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkOpticalFlowSessionCreateFlagBitsNV(api_dump, static_cast<VkOpticalFlowSessionCreateFlagBitsNV>(object), 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);
+void dump_VkOpticalFlowExecuteFlagsNV(ApiDumpInstance& api_dump, const VkOpticalFlowExecuteFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkOpticalFlowExecuteFlagBitsNV(api_dump, static_cast<VkOpticalFlowExecuteFlagBitsNV>(object), 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);
+void dump_VkShaderCreateFlagsEXT(ApiDumpInstance& api_dump, const VkShaderCreateFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkShaderCreateFlagBitsEXT(api_dump, static_cast<VkShaderCreateFlagBitsEXT>(object), 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);
+void dump_VkDataGraphPipelineSessionCreateFlagsARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionCreateFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDataGraphPipelineSessionCreateFlagBitsARM(api_dump, static_cast<VkDataGraphPipelineSessionCreateFlagBitsARM>(object), 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);
+void dump_VkDataGraphPipelineDispatchFlagsARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineDispatchFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkDataGraphPipelineDispatchFlagBitsARM(api_dump, static_cast<VkDataGraphPipelineDispatchFlagBitsARM>(object), 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);
+void dump_VkClusterAccelerationStructureAddressResolutionFlagsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureAddressResolutionFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(api_dump, static_cast<VkClusterAccelerationStructureAddressResolutionFlagBitsNV>(object), 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);
+void dump_VkClusterAccelerationStructureClusterFlagsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureClusterFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkClusterAccelerationStructureClusterFlagBitsNV(api_dump, static_cast<VkClusterAccelerationStructureClusterFlagBitsNV>(object), 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);
+void dump_VkClusterAccelerationStructureGeometryFlagsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureGeometryFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkClusterAccelerationStructureGeometryFlagBitsNV(api_dump, static_cast<VkClusterAccelerationStructureGeometryFlagBitsNV>(object), 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);
+void dump_VkClusterAccelerationStructureIndexFormatFlagsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureIndexFormatFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkClusterAccelerationStructureIndexFormatFlagBitsNV(api_dump, static_cast<VkClusterAccelerationStructureIndexFormatFlagBitsNV>(object), 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);
+void dump_VkPartitionedAccelerationStructureInstanceFlagsNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureInstanceFlagsNV object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkPartitionedAccelerationStructureInstanceFlagBitsNV(api_dump, static_cast<VkPartitionedAccelerationStructureInstanceFlagBitsNV>(object), 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);
+void dump_VkIndirectCommandsInputModeFlagsEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsInputModeFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkIndirectCommandsInputModeFlagBitsEXT(api_dump, static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(object), 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);
+void dump_VkIndirectCommandsLayoutUsageFlagsEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutUsageFlagsEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkIndirectCommandsLayoutUsageFlagBitsEXT(api_dump, static_cast<VkIndirectCommandsLayoutUsageFlagBitsEXT>(object), 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);
+void dump_VkSurfaceCreateFlagsOHOS(ApiDumpInstance& api_dump, const VkSurfaceCreateFlagsOHOS object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, 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);
+void dump_VkPerformanceCounterDescriptionFlagsARM(ApiDumpInstance& api_dump, const VkPerformanceCounterDescriptionFlagsARM object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_value(api_dump, object);
+    dump_end(api_dump, OutputConstruct::value, indents);
 }
-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);
+void dump_VkAccelerationStructureCreateFlagsKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureCreateFlagsKHR object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_VkAccelerationStructureCreateFlagBitsKHR(api_dump, static_cast<VkAccelerationStructureCreateFlagBitsKHR>(object), type_name, var_name, indents, address);
 }
 
 //======================= 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);
+void dump_PFN_vkAllocationFunction(ApiDumpInstance& api_dump, const PFN_vkAllocationFunction object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkFreeFunction(ApiDumpInstance& api_dump, const PFN_vkFreeFunction object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkInternalAllocationNotification(ApiDumpInstance& api_dump, const PFN_vkInternalAllocationNotification object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkInternalFreeNotification(ApiDumpInstance& api_dump, const PFN_vkInternalFreeNotification object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkReallocationFunction(ApiDumpInstance& api_dump, const PFN_vkReallocationFunction object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkVoidFunction(ApiDumpInstance& api_dump, const PFN_vkVoidFunction object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkDebugReportCallbackEXT(ApiDumpInstance& api_dump, const PFN_vkDebugReportCallbackEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkDebugUtilsMessengerCallbackEXT(ApiDumpInstance& api_dump, const PFN_vkDebugUtilsMessengerCallbackEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkDeviceMemoryReportCallbackEXT(ApiDumpInstance& api_dump, const PFN_vkDeviceMemoryReportCallbackEXT object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, OutputConstruct::value, indents);
+}
+void dump_PFN_vkGetInstanceProcAddrLUNARG(ApiDumpInstance& api_dump, const PFN_vkGetInstanceProcAddrLUNARG object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+    dump_address(api_dump, &object);
+    dump_end(api_dump, 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);
+void dump_StdVideoH264SpsVuiFlags(ApiDumpInstance& api_dump, const StdVideoH264SpsVuiFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.aspect_ratio_info_present_flag, "uint32_t: 1", "aspect_ratio_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.overscan_info_present_flag, "uint32_t: 1", "overscan_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.overscan_appropriate_flag, "uint32_t: 1", "overscan_appropriate_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.video_signal_type_present_flag, "uint32_t: 1", "video_signal_type_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.video_full_range_flag, "uint32_t: 1", "video_full_range_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.color_description_present_flag, "uint32_t: 1", "color_description_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_loc_info_present_flag, "uint32_t: 1", "chroma_loc_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.timing_info_present_flag, "uint32_t: 1", "timing_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.fixed_frame_rate_flag, "uint32_t: 1", "fixed_frame_rate_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bitstream_restriction_flag, "uint32_t: 1", "bitstream_restriction_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.nal_hrd_parameters_present_flag, "uint32_t: 1", "nal_hrd_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vcl_hrd_parameters_present_flag, "uint32_t: 1", "vcl_hrd_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264HrdParameters(ApiDumpInstance& api_dump, const StdVideoH264HrdParameters& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.cpb_cnt_minus1, "uint8_t", "cpb_cnt_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bit_rate_scale, "uint8_t", "bit_rate_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cpb_size_scale, "uint8_t", "cpb_size_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.bit_rate_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, "uint32_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "bit_rate_value_minus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cpb_size_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, "uint32_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "cpb_size_value_minus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cbr_flag, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, "uint8_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "cbr_flag", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.initial_cpb_removal_delay_length_minus1, "uint32_t", "initial_cpb_removal_delay_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cpb_removal_delay_length_minus1, "uint32_t", "cpb_removal_delay_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dpb_output_delay_length_minus1, "uint32_t", "dpb_output_delay_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.time_offset_length, "uint32_t", "time_offset_length", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264SequenceParameterSetVui(ApiDumpInstance& api_dump, const StdVideoH264SequenceParameterSetVui& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH264SpsVuiFlags(api_dump, object.flags, "StdVideoH264SpsVuiFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264AspectRatioIdc(api_dump, object.aspect_ratio_idc, "StdVideoH264AspectRatioIdc", "aspect_ratio_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.sar_width, "uint16_t", "sar_width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.sar_height, "uint16_t", "sar_height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.video_format, "uint8_t", "video_format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colour_primaries, "uint8_t", "colour_primaries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transfer_characteristics, "uint8_t", "transfer_characteristics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.matrix_coefficients, "uint8_t", "matrix_coefficients", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_units_in_tick, "uint32_t", "num_units_in_tick", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.time_scale, "uint32_t", "time_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_num_reorder_frames, "uint8_t", "max_num_reorder_frames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_dec_frame_buffering, "uint8_t", "max_dec_frame_buffering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_sample_loc_type_top_field, "uint8_t", "chroma_sample_loc_type_top_field", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_sample_loc_type_bottom_field, "uint8_t", "chroma_sample_loc_type_bottom_field", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint32_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pHrdParameters, "const StdVideoH264HrdParameters*", "pHrdParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264HrdParameters);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264SpsFlags(ApiDumpInstance& api_dump, const StdVideoH264SpsFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.constraint_set0_flag, "uint32_t: 1", "constraint_set0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constraint_set1_flag, "uint32_t: 1", "constraint_set1_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constraint_set2_flag, "uint32_t: 1", "constraint_set2_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constraint_set3_flag, "uint32_t: 1", "constraint_set3_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constraint_set4_flag, "uint32_t: 1", "constraint_set4_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constraint_set5_flag, "uint32_t: 1", "constraint_set5_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.direct_8x8_inference_flag, "uint32_t: 1", "direct_8x8_inference_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mb_adaptive_frame_field_flag, "uint32_t: 1", "mb_adaptive_frame_field_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_mbs_only_flag, "uint32_t: 1", "frame_mbs_only_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_pic_order_always_zero_flag, "uint32_t: 1", "delta_pic_order_always_zero_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.separate_colour_plane_flag, "uint32_t: 1", "separate_colour_plane_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gaps_in_frame_num_value_allowed_flag, "uint32_t: 1", "gaps_in_frame_num_value_allowed_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.qpprime_y_zero_transform_bypass_flag, "uint32_t: 1", "qpprime_y_zero_transform_bypass_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_cropping_flag, "uint32_t: 1", "frame_cropping_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_scaling_matrix_present_flag, "uint32_t: 1", "seq_scaling_matrix_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_parameters_present_flag, "uint32_t: 1", "vui_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264ScalingLists(ApiDumpInstance& api_dump, const StdVideoH264ScalingLists& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint16_t>(api_dump, object.scaling_list_present_mask, "uint16_t", "scaling_list_present_mask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.use_default_scaling_matrix_mask, "uint16_t", "use_default_scaling_matrix_mask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.ScalingList4x4, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS, "uint8_t[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]", "ScalingList4x4", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.ScalingList8x8, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS, "uint8_t[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]", "ScalingList8x8", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264SequenceParameterSet(ApiDumpInstance& api_dump, const StdVideoH264SequenceParameterSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH264SpsFlags(api_dump, object.flags, "StdVideoH264SpsFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264ProfileIdc(api_dump, object.profile_idc, "StdVideoH264ProfileIdc", "profile_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264LevelIdc(api_dump, object.level_idc, "StdVideoH264LevelIdc", "level_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264ChromaFormatIdc(api_dump, object.chroma_format_idc, "StdVideoH264ChromaFormatIdc", "chroma_format_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_parameter_set_id, "uint8_t", "seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bit_depth_luma_minus8, "uint8_t", "bit_depth_luma_minus8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bit_depth_chroma_minus8, "uint8_t", "bit_depth_chroma_minus8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_max_frame_num_minus4, "uint8_t", "log2_max_frame_num_minus4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264PocType(api_dump, object.pic_order_cnt_type, "StdVideoH264PocType", "pic_order_cnt_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.offset_for_non_ref_pic, "int32_t", "offset_for_non_ref_pic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.offset_for_top_to_bottom_field, "int32_t", "offset_for_top_to_bottom_field", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_max_pic_order_cnt_lsb_minus4, "uint8_t", "log2_max_pic_order_cnt_lsb_minus4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_frames_in_pic_order_cnt_cycle, "uint8_t", "num_ref_frames_in_pic_order_cnt_cycle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_num_ref_frames, "uint8_t", "max_num_ref_frames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_width_in_mbs_minus1, "uint32_t", "pic_width_in_mbs_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_height_in_map_units_minus1, "uint32_t", "pic_height_in_map_units_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_crop_left_offset, "uint32_t", "frame_crop_left_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_crop_right_offset, "uint32_t", "frame_crop_right_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_crop_top_offset, "uint32_t", "frame_crop_top_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_crop_bottom_offset, "uint32_t", "frame_crop_bottom_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint32_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pOffsetForRefFrame, object.num_ref_frames_in_pic_order_cnt_cycle, "const int32_t*", "pOffsetForRefFrame", "const int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const int32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pScalingLists, "const StdVideoH264ScalingLists*", "pScalingLists", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264ScalingLists);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSequenceParameterSetVui, "const StdVideoH264SequenceParameterSetVui*", "pSequenceParameterSetVui", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSetVui);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264PpsFlags(ApiDumpInstance& api_dump, const StdVideoH264PpsFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.transform_8x8_mode_flag, "uint32_t: 1", "transform_8x8_mode_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.redundant_pic_cnt_present_flag, "uint32_t: 1", "redundant_pic_cnt_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constrained_intra_pred_flag, "uint32_t: 1", "constrained_intra_pred_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deblocking_filter_control_present_flag, "uint32_t: 1", "deblocking_filter_control_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.weighted_pred_flag, "uint32_t: 1", "weighted_pred_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bottom_field_pic_order_in_frame_present_flag, "uint32_t: 1", "bottom_field_pic_order_in_frame_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.entropy_coding_mode_flag, "uint32_t: 1", "entropy_coding_mode_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_scaling_matrix_present_flag, "uint32_t: 1", "pic_scaling_matrix_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH264PictureParameterSet(ApiDumpInstance& api_dump, const StdVideoH264PictureParameterSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH264PpsFlags(api_dump, object.flags, "StdVideoH264PpsFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_parameter_set_id, "uint8_t", "seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_parameter_set_id, "uint8_t", "pic_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l0_default_active_minus1, "uint8_t", "num_ref_idx_l0_default_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l1_default_active_minus1, "uint8_t", "num_ref_idx_l1_default_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264WeightedBipredIdc(api_dump, object.weighted_bipred_idc, "StdVideoH264WeightedBipredIdc", "weighted_bipred_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pic_init_qp_minus26, "int8_t", "pic_init_qp_minus26", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pic_init_qs_minus26, "int8_t", "pic_init_qs_minus26", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.chroma_qp_index_offset, "int8_t", "chroma_qp_index_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.second_chroma_qp_index_offset, "int8_t", "second_chroma_qp_index_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pScalingLists, "const StdVideoH264ScalingLists*", "pScalingLists", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264ScalingLists);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH264PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeH264PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.field_pic_flag, "uint32_t: 1", "field_pic_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_intra, "uint32_t: 1", "is_intra", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.IdrPicFlag, "uint32_t: 1", "IdrPicFlag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bottom_field_flag, "uint32_t: 1", "bottom_field_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_reference, "uint32_t: 1", "is_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.complementary_field_pair, "uint32_t: 1", "complementary_field_pair", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH264PictureInfo(ApiDumpInstance& api_dump, const StdVideoDecodeH264PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeH264PictureInfoFlags(api_dump, object.flags, "StdVideoDecodeH264PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_parameter_set_id, "uint8_t", "seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_parameter_set_id, "uint8_t", "pic_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint8_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.frame_num, "uint16_t", "frame_num", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.idr_pic_id, "uint16_t", "idr_pic_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE, "int32_t[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]", "PicOrderCnt", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH264ReferenceInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeH264ReferenceInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.top_field_flag, "uint32_t: 1", "top_field_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bottom_field_flag, "uint32_t: 1", "bottom_field_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.used_for_long_term_reference, "uint32_t: 1", "used_for_long_term_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_non_existing, "uint32_t: 1", "is_non_existing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH264ReferenceInfo(ApiDumpInstance& api_dump, const StdVideoDecodeH264ReferenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeH264ReferenceInfoFlags(api_dump, object.flags, "StdVideoDecodeH264ReferenceInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.FrameNum, "uint16_t", "FrameNum", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.reserved, "uint16_t", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE, "int32_t[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]", "PicOrderCnt", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264WeightTableFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH264WeightTableFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.luma_weight_l0_flag, "uint32_t", "luma_weight_l0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_weight_l0_flag, "uint32_t", "chroma_weight_l0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.luma_weight_l1_flag, "uint32_t", "luma_weight_l1_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_weight_l1_flag, "uint32_t", "chroma_weight_l1_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264WeightTable(ApiDumpInstance& api_dump, const StdVideoEncodeH264WeightTable& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH264WeightTableFlags(api_dump, object.flags, "StdVideoEncodeH264WeightTableFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.luma_log2_weight_denom, "uint8_t", "luma_log2_weight_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_log2_weight_denom, "uint8_t", "chroma_log2_weight_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.luma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_weight_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.luma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_offset_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.chroma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_weight_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.chroma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_offset_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.luma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_weight_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.luma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_offset_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.chroma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_weight_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.chroma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_offset_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264SliceHeaderFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH264SliceHeaderFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.direct_spatial_mv_pred_flag, "uint32_t: 1", "direct_spatial_mv_pred_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_active_override_flag, "uint32_t: 1", "num_ref_idx_active_override_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH264PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.IdrPicFlag, "uint32_t: 1", "IdrPicFlag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_reference, "uint32_t: 1", "is_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.no_output_of_prior_pics_flag, "uint32_t: 1", "no_output_of_prior_pics_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.long_term_reference_flag, "uint32_t: 1", "long_term_reference_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.adaptive_ref_pic_marking_mode_flag, "uint32_t: 1", "adaptive_ref_pic_marking_mode_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 27", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264ReferenceInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH264ReferenceInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.used_for_long_term_reference, "uint32_t: 1", "used_for_long_term_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 31", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264ReferenceListsInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH264ReferenceListsInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.ref_pic_list_modification_flag_l0, "uint32_t: 1", "ref_pic_list_modification_flag_l0", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.ref_pic_list_modification_flag_l1, "uint32_t: 1", "ref_pic_list_modification_flag_l1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264RefListModEntry(ApiDumpInstance& api_dump, const StdVideoEncodeH264RefListModEntry& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH264ModificationOfPicNumsIdc(api_dump, object.modification_of_pic_nums_idc, "StdVideoH264ModificationOfPicNumsIdc", "modification_of_pic_nums_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.abs_diff_pic_num_minus1, "uint16_t", "abs_diff_pic_num_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.long_term_pic_num, "uint16_t", "long_term_pic_num", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264RefPicMarkingEntry(ApiDumpInstance& api_dump, const StdVideoEncodeH264RefPicMarkingEntry& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH264MemMgmtControlOp(api_dump, object.memory_management_control_operation, "StdVideoH264MemMgmtControlOp", "memory_management_control_operation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.difference_of_pic_nums_minus1, "uint16_t", "difference_of_pic_nums_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.long_term_pic_num, "uint16_t", "long_term_pic_num", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.long_term_frame_idx, "uint16_t", "long_term_frame_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.max_long_term_frame_idx_plus1, "uint16_t", "max_long_term_frame_idx_plus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264ReferenceListsInfo(ApiDumpInstance& api_dump, const StdVideoEncodeH264ReferenceListsInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH264ReferenceListsInfoFlags(api_dump, object.flags, "StdVideoEncodeH264ReferenceListsInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l0_active_minus1, "uint8_t", "num_ref_idx_l0_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l1_active_minus1, "uint8_t", "num_ref_idx_l1_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicList0, STD_VIDEO_H264_MAX_NUM_LIST_REF, "uint8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "RefPicList0", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicList1, STD_VIDEO_H264_MAX_NUM_LIST_REF, "uint8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "RefPicList1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refList0ModOpCount, "uint8_t", "refList0ModOpCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refList1ModOpCount, "uint8_t", "refList1ModOpCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refPicMarkingOpCount, "uint8_t", "refPicMarkingOpCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 7, "uint8_t[7]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRefList0ModOperations, object.refList0ModOpCount, "const StdVideoEncodeH264RefListModEntry*", "pRefList0ModOperations", "const StdVideoEncodeH264RefListModEntry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefListModEntry);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRefList1ModOperations, object.refList1ModOpCount, "const StdVideoEncodeH264RefListModEntry*", "pRefList1ModOperations", "const StdVideoEncodeH264RefListModEntry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefListModEntry);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRefPicMarkingOperations, object.refPicMarkingOpCount, "const StdVideoEncodeH264RefPicMarkingEntry*", "pRefPicMarkingOperations", "const StdVideoEncodeH264RefPicMarkingEntry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefPicMarkingEntry);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264PictureInfo(ApiDumpInstance& api_dump, const StdVideoEncodeH264PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH264PictureInfoFlags(api_dump, object.flags, "StdVideoEncodeH264PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_parameter_set_id, "uint8_t", "seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_parameter_set_id, "uint8_t", "pic_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.idr_pic_id, "uint16_t", "idr_pic_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264PictureType(api_dump, object.primary_pic_type, "StdVideoH264PictureType", "primary_pic_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_num, "uint32_t", "frame_num", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.PicOrderCnt, "int32_t", "PicOrderCnt", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.temporal_id, "uint8_t", "temporal_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 3, "uint8_t[3]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pRefLists, "const StdVideoEncodeH264ReferenceListsInfo*", "pRefLists", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264ReferenceListsInfo);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264ReferenceInfo(ApiDumpInstance& api_dump, const StdVideoEncodeH264ReferenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH264ReferenceInfoFlags(api_dump, object.flags, "StdVideoEncodeH264ReferenceInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264PictureType(api_dump, object.primary_pic_type, "StdVideoH264PictureType", "primary_pic_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.FrameNum, "uint32_t", "FrameNum", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.PicOrderCnt, "int32_t", "PicOrderCnt", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.long_term_pic_num, "uint16_t", "long_term_pic_num", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.long_term_frame_idx, "uint16_t", "long_term_frame_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.temporal_id, "uint8_t", "temporal_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH264SliceHeader(ApiDumpInstance& api_dump, const StdVideoEncodeH264SliceHeader& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH264SliceHeaderFlags(api_dump, object.flags, "StdVideoEncodeH264SliceHeaderFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.first_mb_in_slice, "uint32_t", "first_mb_in_slice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264SliceType(api_dump, object.slice_type, "StdVideoH264SliceType", "slice_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_alpha_c0_offset_div2, "int8_t", "slice_alpha_c0_offset_div2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_beta_offset_div2, "int8_t", "slice_beta_offset_div2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_qp_delta, "int8_t", "slice_qp_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264CabacInitIdc(api_dump, object.cabac_init_idc, "StdVideoH264CabacInitIdc", "cabac_init_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264DisableDeblockingFilterIdc(api_dump, object.disable_deblocking_filter_idc, "StdVideoH264DisableDeblockingFilterIdc", "disable_deblocking_filter_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pWeightTable, "const StdVideoEncodeH264WeightTable*", "pWeightTable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264WeightTable);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265DecPicBufMgr(ApiDumpInstance& api_dump, const StdVideoH265DecPicBufMgr& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_single_array(api_dump, object.max_latency_increase_plus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, "uint32_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_latency_increase_plus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.max_dec_pic_buffering_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_dec_pic_buffering_minus1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.max_num_reorder_pics, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_num_reorder_pics", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265SubLayerHrdParameters(ApiDumpInstance& api_dump, const StdVideoH265SubLayerHrdParameters& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_single_array(api_dump, object.bit_rate_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "bit_rate_value_minus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cpb_size_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "cpb_size_value_minus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cpb_size_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "cpb_size_du_value_minus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.bit_rate_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "bit_rate_du_value_minus1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cbr_flag, "uint32_t", "cbr_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265HrdFlags(ApiDumpInstance& api_dump, const StdVideoH265HrdFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.nal_hrd_parameters_present_flag, "uint32_t: 1", "nal_hrd_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vcl_hrd_parameters_present_flag, "uint32_t: 1", "vcl_hrd_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sub_pic_hrd_params_present_flag, "uint32_t: 1", "sub_pic_hrd_params_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sub_pic_cpb_params_in_pic_timing_sei_flag, "uint32_t: 1", "sub_pic_cpb_params_in_pic_timing_sei_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.fixed_pic_rate_general_flag, "uint32_t: 8", "fixed_pic_rate_general_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.fixed_pic_rate_within_cvs_flag, "uint32_t: 8", "fixed_pic_rate_within_cvs_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.low_delay_hrd_flag, "uint32_t: 8", "low_delay_hrd_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265HrdParameters(ApiDumpInstance& api_dump, const StdVideoH265HrdParameters& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH265HrdFlags(api_dump, object.flags, "StdVideoH265HrdFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tick_divisor_minus2, "uint8_t", "tick_divisor_minus2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.du_cpb_removal_delay_increment_length_minus1, "uint8_t", "du_cpb_removal_delay_increment_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dpb_output_delay_du_length_minus1, "uint8_t", "dpb_output_delay_du_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bit_rate_scale, "uint8_t", "bit_rate_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cpb_size_scale, "uint8_t", "cpb_size_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cpb_size_du_scale, "uint8_t", "cpb_size_du_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.initial_cpb_removal_delay_length_minus1, "uint8_t", "initial_cpb_removal_delay_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.au_cpb_removal_delay_length_minus1, "uint8_t", "au_cpb_removal_delay_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dpb_output_delay_length_minus1, "uint8_t", "dpb_output_delay_length_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cpb_cnt_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "cpb_cnt_minus1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.elemental_duration_in_tc_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, "uint16_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "elemental_duration_in_tc_minus1", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved, 3, "uint16_t[3]", "reserved", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pSubLayerHrdParametersNal, api_dump.getIsInVps() ? api_dump.getVpsMaxSubLayersMinus1() : api_dump.getSpsMaxSubLayersMinus1(), "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", "const StdVideoH265SubLayerHrdParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SubLayerHrdParameters);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", indents + 2);
         }
     }
-    dump_separate_members<Format>(settings);
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pSubLayerHrdParametersVcl, api_dump.getIsInVps() ? api_dump.getVpsMaxSubLayersMinus1() : api_dump.getSpsMaxSubLayersMinus1(), "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", "const StdVideoH265SubLayerHrdParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SubLayerHrdParameters);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265VpsFlags(ApiDumpInstance& api_dump, const StdVideoH265VpsFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.vps_temporal_id_nesting_flag, "uint32_t: 1", "vps_temporal_id_nesting_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_sub_layer_ordering_info_present_flag, "uint32_t: 1", "vps_sub_layer_ordering_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_timing_info_present_flag, "uint32_t: 1", "vps_timing_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_poc_proportional_to_timing_flag, "uint32_t: 1", "vps_poc_proportional_to_timing_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265ProfileTierLevelFlags(ApiDumpInstance& api_dump, const StdVideoH265ProfileTierLevelFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.general_tier_flag, "uint32_t: 1", "general_tier_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.general_progressive_source_flag, "uint32_t: 1", "general_progressive_source_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.general_interlaced_source_flag, "uint32_t: 1", "general_interlaced_source_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.general_non_packed_constraint_flag, "uint32_t: 1", "general_non_packed_constraint_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.general_frame_only_constraint_flag, "uint32_t: 1", "general_frame_only_constraint_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265ProfileTierLevel(ApiDumpInstance& api_dump, const StdVideoH265ProfileTierLevel& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH265ProfileTierLevelFlags(api_dump, object.flags, "StdVideoH265ProfileTierLevelFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265ProfileIdc(api_dump, object.general_profile_idc, "StdVideoH265ProfileIdc", "general_profile_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265LevelIdc(api_dump, object.general_level_idc, "StdVideoH265LevelIdc", "general_level_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265VideoParameterSet(ApiDumpInstance& api_dump, const StdVideoH265VideoParameterSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setVpsMaxSubLayersMinus1(object.vps_max_sub_layers_minus1);
+    api_dump.setIsInVps(true);
+    dump_StdVideoH265VpsFlags(api_dump, object.flags, "StdVideoH265VpsFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_video_parameter_set_id, "uint8_t", "vps_video_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_max_sub_layers_minus1, "uint8_t", "vps_max_sub_layers_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint8_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_num_units_in_tick, "uint32_t", "vps_num_units_in_tick", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_time_scale, "uint32_t", "vps_time_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vps_num_ticks_poc_diff_one_minus1, "uint32_t", "vps_num_ticks_poc_diff_one_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved3, "uint32_t", "reserved3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDecPicBufMgr, "const StdVideoH265DecPicBufMgr*", "pDecPicBufMgr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265DecPicBufMgr);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pHrdParameters, "const StdVideoH265HrdParameters*", "pHrdParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265HrdParameters);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pProfileTierLevel, "const StdVideoH265ProfileTierLevel*", "pProfileTierLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ProfileTierLevel);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265ScalingLists(ApiDumpInstance& api_dump, const StdVideoH265ScalingLists& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_double_array(api_dump, object.ScalingList4x4, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS, "uint8_t[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]", "ScalingList4x4", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.ScalingList8x8, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS, "uint8_t[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]", "ScalingList8x8", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.ScalingList16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS, "uint8_t[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]", "ScalingList16x16", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.ScalingList32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS, "uint8_t[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]", "ScalingList32x32", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ScalingListDCCoef16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, "uint8_t[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]", "ScalingListDCCoef16x16", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ScalingListDCCoef32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, "uint8_t[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]", "ScalingListDCCoef32x32", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265SpsVuiFlags(ApiDumpInstance& api_dump, const StdVideoH265SpsVuiFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.aspect_ratio_info_present_flag, "uint32_t: 1", "aspect_ratio_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.overscan_info_present_flag, "uint32_t: 1", "overscan_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.overscan_appropriate_flag, "uint32_t: 1", "overscan_appropriate_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.video_signal_type_present_flag, "uint32_t: 1", "video_signal_type_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.video_full_range_flag, "uint32_t: 1", "video_full_range_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colour_description_present_flag, "uint32_t: 1", "colour_description_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_loc_info_present_flag, "uint32_t: 1", "chroma_loc_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.neutral_chroma_indication_flag, "uint32_t: 1", "neutral_chroma_indication_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.field_seq_flag, "uint32_t: 1", "field_seq_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_field_info_present_flag, "uint32_t: 1", "frame_field_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.default_display_window_flag, "uint32_t: 1", "default_display_window_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_timing_info_present_flag, "uint32_t: 1", "vui_timing_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_poc_proportional_to_timing_flag, "uint32_t: 1", "vui_poc_proportional_to_timing_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_hrd_parameters_present_flag, "uint32_t: 1", "vui_hrd_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bitstream_restriction_flag, "uint32_t: 1", "bitstream_restriction_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tiles_fixed_structure_flag, "uint32_t: 1", "tiles_fixed_structure_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.motion_vectors_over_pic_boundaries_flag, "uint32_t: 1", "motion_vectors_over_pic_boundaries_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.restricted_ref_pic_lists_flag, "uint32_t: 1", "restricted_ref_pic_lists_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265SequenceParameterSetVui(ApiDumpInstance& api_dump, const StdVideoH265SequenceParameterSetVui& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH265SpsVuiFlags(api_dump, object.flags, "StdVideoH265SpsVuiFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265AspectRatioIdc(api_dump, object.aspect_ratio_idc, "StdVideoH265AspectRatioIdc", "aspect_ratio_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.sar_width, "uint16_t", "sar_width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.sar_height, "uint16_t", "sar_height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.video_format, "uint8_t", "video_format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colour_primaries, "uint8_t", "colour_primaries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transfer_characteristics, "uint8_t", "transfer_characteristics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.matrix_coeffs, "uint8_t", "matrix_coeffs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_sample_loc_type_top_field, "uint8_t", "chroma_sample_loc_type_top_field", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_sample_loc_type_bottom_field, "uint8_t", "chroma_sample_loc_type_bottom_field", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint8_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.def_disp_win_left_offset, "uint16_t", "def_disp_win_left_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.def_disp_win_right_offset, "uint16_t", "def_disp_win_right_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.def_disp_win_top_offset, "uint16_t", "def_disp_win_top_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.def_disp_win_bottom_offset, "uint16_t", "def_disp_win_bottom_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_num_units_in_tick, "uint32_t", "vui_num_units_in_tick", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_time_scale, "uint32_t", "vui_time_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_num_ticks_poc_diff_one_minus1, "uint32_t", "vui_num_ticks_poc_diff_one_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.min_spatial_segmentation_idc, "uint16_t", "min_spatial_segmentation_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.reserved3, "uint16_t", "reserved3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_bytes_per_pic_denom, "uint8_t", "max_bytes_per_pic_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_bits_per_min_cu_denom, "uint8_t", "max_bits_per_min_cu_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_max_mv_length_horizontal, "uint8_t", "log2_max_mv_length_horizontal", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_max_mv_length_vertical, "uint8_t", "log2_max_mv_length_vertical", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pHrdParameters, "const StdVideoH265HrdParameters*", "pHrdParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265HrdParameters);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265PredictorPaletteEntries(ApiDumpInstance& api_dump, const StdVideoH265PredictorPaletteEntries& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_double_array(api_dump, object.PredictorPaletteEntries, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE, "uint16_t[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]", "PredictorPaletteEntries", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265SpsFlags(ApiDumpInstance& api_dump, const StdVideoH265SpsFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.sps_temporal_id_nesting_flag, "uint32_t: 1", "sps_temporal_id_nesting_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.separate_colour_plane_flag, "uint32_t: 1", "separate_colour_plane_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.conformance_window_flag, "uint32_t: 1", "conformance_window_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_sub_layer_ordering_info_present_flag, "uint32_t: 1", "sps_sub_layer_ordering_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.scaling_list_enabled_flag, "uint32_t: 1", "scaling_list_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_scaling_list_data_present_flag, "uint32_t: 1", "sps_scaling_list_data_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.amp_enabled_flag, "uint32_t: 1", "amp_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sample_adaptive_offset_enabled_flag, "uint32_t: 1", "sample_adaptive_offset_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pcm_enabled_flag, "uint32_t: 1", "pcm_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pcm_loop_filter_disabled_flag, "uint32_t: 1", "pcm_loop_filter_disabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.long_term_ref_pics_present_flag, "uint32_t: 1", "long_term_ref_pics_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_temporal_mvp_enabled_flag, "uint32_t: 1", "sps_temporal_mvp_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.strong_intra_smoothing_enabled_flag, "uint32_t: 1", "strong_intra_smoothing_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vui_parameters_present_flag, "uint32_t: 1", "vui_parameters_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_extension_present_flag, "uint32_t: 1", "sps_extension_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_range_extension_flag, "uint32_t: 1", "sps_range_extension_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transform_skip_rotation_enabled_flag, "uint32_t: 1", "transform_skip_rotation_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transform_skip_context_enabled_flag, "uint32_t: 1", "transform_skip_context_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.implicit_rdpcm_enabled_flag, "uint32_t: 1", "implicit_rdpcm_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.explicit_rdpcm_enabled_flag, "uint32_t: 1", "explicit_rdpcm_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.extended_precision_processing_flag, "uint32_t: 1", "extended_precision_processing_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intra_smoothing_disabled_flag, "uint32_t: 1", "intra_smoothing_disabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.high_precision_offsets_enabled_flag, "uint32_t: 1", "high_precision_offsets_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.persistent_rice_adaptation_enabled_flag, "uint32_t: 1", "persistent_rice_adaptation_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cabac_bypass_alignment_enabled_flag, "uint32_t: 1", "cabac_bypass_alignment_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_scc_extension_flag, "uint32_t: 1", "sps_scc_extension_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_curr_pic_ref_enabled_flag, "uint32_t: 1", "sps_curr_pic_ref_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.palette_mode_enabled_flag, "uint32_t: 1", "palette_mode_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_palette_predictor_initializers_present_flag, "uint32_t: 1", "sps_palette_predictor_initializers_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intra_boundary_filtering_disabled_flag, "uint32_t: 1", "intra_boundary_filtering_disabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265ShortTermRefPicSetFlags(ApiDumpInstance& api_dump, const StdVideoH265ShortTermRefPicSetFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.inter_ref_pic_set_prediction_flag, "uint32_t: 1", "inter_ref_pic_set_prediction_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_rps_sign, "uint32_t: 1", "delta_rps_sign", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265ShortTermRefPicSet(ApiDumpInstance& api_dump, const StdVideoH265ShortTermRefPicSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH265ShortTermRefPicSetFlags(api_dump, object.flags, "StdVideoH265ShortTermRefPicSetFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_idx_minus1, "uint32_t", "delta_idx_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.use_delta_flag, "uint16_t", "use_delta_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.abs_delta_rps_minus1, "uint16_t", "abs_delta_rps_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.used_by_curr_pic_flag, "uint16_t", "used_by_curr_pic_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.used_by_curr_pic_s0_flag, "uint16_t", "used_by_curr_pic_s0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.used_by_curr_pic_s1_flag, "uint16_t", "used_by_curr_pic_s1_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.reserved1, "uint16_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint8_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved3, "uint8_t", "reserved3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_negative_pics, "uint8_t", "num_negative_pics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_positive_pics, "uint8_t", "num_positive_pics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_poc_s0_minus1, STD_VIDEO_H265_MAX_DPB_SIZE, "uint16_t[STD_VIDEO_H265_MAX_DPB_SIZE]", "delta_poc_s0_minus1", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_poc_s1_minus1, STD_VIDEO_H265_MAX_DPB_SIZE, "uint16_t[STD_VIDEO_H265_MAX_DPB_SIZE]", "delta_poc_s1_minus1", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265LongTermRefPicsSps(ApiDumpInstance& api_dump, const StdVideoH265LongTermRefPicsSps& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.used_by_curr_pic_lt_sps_flag, "uint32_t", "used_by_curr_pic_lt_sps_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.lt_ref_pic_poc_lsb_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS, "uint32_t[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]", "lt_ref_pic_poc_lsb_sps", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265SequenceParameterSet(ApiDumpInstance& api_dump, const StdVideoH265SequenceParameterSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setSpsMaxSubLayersMinus1(object.sps_max_sub_layers_minus1);
+    api_dump.setIsInVps(false);
+    dump_StdVideoH265SpsFlags(api_dump, object.flags, "StdVideoH265SpsFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265ChromaFormatIdc(api_dump, object.chroma_format_idc, "StdVideoH265ChromaFormatIdc", "chroma_format_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_width_in_luma_samples, "uint32_t", "pic_width_in_luma_samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_height_in_luma_samples, "uint32_t", "pic_height_in_luma_samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_video_parameter_set_id, "uint8_t", "sps_video_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_max_sub_layers_minus1, "uint8_t", "sps_max_sub_layers_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_seq_parameter_set_id, "uint8_t", "sps_seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bit_depth_luma_minus8, "uint8_t", "bit_depth_luma_minus8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bit_depth_chroma_minus8, "uint8_t", "bit_depth_chroma_minus8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_max_pic_order_cnt_lsb_minus4, "uint8_t", "log2_max_pic_order_cnt_lsb_minus4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_min_luma_coding_block_size_minus3, "uint8_t", "log2_min_luma_coding_block_size_minus3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_diff_max_min_luma_coding_block_size, "uint8_t", "log2_diff_max_min_luma_coding_block_size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_min_luma_transform_block_size_minus2, "uint8_t", "log2_min_luma_transform_block_size_minus2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_diff_max_min_luma_transform_block_size, "uint8_t", "log2_diff_max_min_luma_transform_block_size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_transform_hierarchy_depth_inter, "uint8_t", "max_transform_hierarchy_depth_inter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.max_transform_hierarchy_depth_intra, "uint8_t", "max_transform_hierarchy_depth_intra", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_short_term_ref_pic_sets, "uint8_t", "num_short_term_ref_pic_sets", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_long_term_ref_pics_sps, "uint8_t", "num_long_term_ref_pics_sps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pcm_sample_bit_depth_luma_minus1, "uint8_t", "pcm_sample_bit_depth_luma_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pcm_sample_bit_depth_chroma_minus1, "uint8_t", "pcm_sample_bit_depth_chroma_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_min_pcm_luma_coding_block_size_minus3, "uint8_t", "log2_min_pcm_luma_coding_block_size_minus3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_diff_max_min_pcm_luma_coding_block_size, "uint8_t", "log2_diff_max_min_pcm_luma_coding_block_size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint8_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.palette_max_size, "uint8_t", "palette_max_size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_palette_max_predictor_size, "uint8_t", "delta_palette_max_predictor_size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.motion_vector_resolution_control_idc, "uint8_t", "motion_vector_resolution_control_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_num_palette_predictor_initializers_minus1, "uint8_t", "sps_num_palette_predictor_initializers_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.conf_win_left_offset, "uint32_t", "conf_win_left_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.conf_win_right_offset, "uint32_t", "conf_win_right_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.conf_win_top_offset, "uint32_t", "conf_win_top_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.conf_win_bottom_offset, "uint32_t", "conf_win_bottom_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pProfileTierLevel, "const StdVideoH265ProfileTierLevel*", "pProfileTierLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ProfileTierLevel);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDecPicBufMgr, "const StdVideoH265DecPicBufMgr*", "pDecPicBufMgr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265DecPicBufMgr);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pScalingLists, "const StdVideoH265ScalingLists*", "pScalingLists", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ScalingLists);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pShortTermRefPicSet, object.num_short_term_ref_pic_sets, "const StdVideoH265ShortTermRefPicSet*", "pShortTermRefPicSet", "const StdVideoH265ShortTermRefPicSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ShortTermRefPicSet);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLongTermRefPicsSps, "const StdVideoH265LongTermRefPicsSps*", "pLongTermRefPicsSps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265LongTermRefPicsSps);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSequenceParameterSetVui, "const StdVideoH265SequenceParameterSetVui*", "pSequenceParameterSetVui", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSetVui);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pPredictorPaletteEntries, "const StdVideoH265PredictorPaletteEntries*", "pPredictorPaletteEntries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PredictorPaletteEntries);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265PpsFlags(ApiDumpInstance& api_dump, const StdVideoH265PpsFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.dependent_slice_segments_enabled_flag, "uint32_t: 1", "dependent_slice_segments_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.output_flag_present_flag, "uint32_t: 1", "output_flag_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sign_data_hiding_enabled_flag, "uint32_t: 1", "sign_data_hiding_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cabac_init_present_flag, "uint32_t: 1", "cabac_init_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constrained_intra_pred_flag, "uint32_t: 1", "constrained_intra_pred_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transform_skip_enabled_flag, "uint32_t: 1", "transform_skip_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cu_qp_delta_enabled_flag, "uint32_t: 1", "cu_qp_delta_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_slice_chroma_qp_offsets_present_flag, "uint32_t: 1", "pps_slice_chroma_qp_offsets_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.weighted_pred_flag, "uint32_t: 1", "weighted_pred_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.weighted_bipred_flag, "uint32_t: 1", "weighted_bipred_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transquant_bypass_enabled_flag, "uint32_t: 1", "transquant_bypass_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tiles_enabled_flag, "uint32_t: 1", "tiles_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.entropy_coding_sync_enabled_flag, "uint32_t: 1", "entropy_coding_sync_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.uniform_spacing_flag, "uint32_t: 1", "uniform_spacing_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.loop_filter_across_tiles_enabled_flag, "uint32_t: 1", "loop_filter_across_tiles_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_loop_filter_across_slices_enabled_flag, "uint32_t: 1", "pps_loop_filter_across_slices_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deblocking_filter_control_present_flag, "uint32_t: 1", "deblocking_filter_control_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deblocking_filter_override_enabled_flag, "uint32_t: 1", "deblocking_filter_override_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_deblocking_filter_disabled_flag, "uint32_t: 1", "pps_deblocking_filter_disabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_scaling_list_data_present_flag, "uint32_t: 1", "pps_scaling_list_data_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.lists_modification_present_flag, "uint32_t: 1", "lists_modification_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_segment_header_extension_present_flag, "uint32_t: 1", "slice_segment_header_extension_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_extension_present_flag, "uint32_t: 1", "pps_extension_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cross_component_prediction_enabled_flag, "uint32_t: 1", "cross_component_prediction_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_qp_offset_list_enabled_flag, "uint32_t: 1", "chroma_qp_offset_list_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_curr_pic_ref_enabled_flag, "uint32_t: 1", "pps_curr_pic_ref_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.residual_adaptive_colour_transform_enabled_flag, "uint32_t: 1", "residual_adaptive_colour_transform_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_slice_act_qp_offsets_present_flag, "uint32_t: 1", "pps_slice_act_qp_offsets_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_palette_predictor_initializers_present_flag, "uint32_t: 1", "pps_palette_predictor_initializers_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.monochrome_palette_flag, "uint32_t: 1", "monochrome_palette_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_range_extension_flag, "uint32_t: 1", "pps_range_extension_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoH265PictureParameterSet(ApiDumpInstance& api_dump, const StdVideoH265PictureParameterSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoH265PpsFlags(api_dump, object.flags, "StdVideoH265PpsFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_pic_parameter_set_id, "uint8_t", "pps_pic_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_seq_parameter_set_id, "uint8_t", "pps_seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_video_parameter_set_id, "uint8_t", "sps_video_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_extra_slice_header_bits, "uint8_t", "num_extra_slice_header_bits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l0_default_active_minus1, "uint8_t", "num_ref_idx_l0_default_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l1_default_active_minus1, "uint8_t", "num_ref_idx_l1_default_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.init_qp_minus26, "int8_t", "init_qp_minus26", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.diff_cu_qp_delta_depth, "uint8_t", "diff_cu_qp_delta_depth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_cb_qp_offset, "int8_t", "pps_cb_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_cr_qp_offset, "int8_t", "pps_cr_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_beta_offset_div2, "int8_t", "pps_beta_offset_div2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_tc_offset_div2, "int8_t", "pps_tc_offset_div2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_parallel_merge_level_minus2, "uint8_t", "log2_parallel_merge_level_minus2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_max_transform_skip_block_size_minus2, "uint8_t", "log2_max_transform_skip_block_size_minus2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.diff_cu_chroma_qp_offset_depth, "uint8_t", "diff_cu_chroma_qp_offset_depth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_qp_offset_list_len_minus1, "uint8_t", "chroma_qp_offset_list_len_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cb_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE, "int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]", "cb_qp_offset_list", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cr_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE, "int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]", "cr_qp_offset_list", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_sao_offset_scale_luma, "uint8_t", "log2_sao_offset_scale_luma", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.log2_sao_offset_scale_chroma, "uint8_t", "log2_sao_offset_scale_chroma", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_act_y_qp_offset_plus5, "int8_t", "pps_act_y_qp_offset_plus5", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_act_cb_qp_offset_plus5, "int8_t", "pps_act_cb_qp_offset_plus5", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.pps_act_cr_qp_offset_plus3, "int8_t", "pps_act_cr_qp_offset_plus3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_num_palette_predictor_initializers, "uint8_t", "pps_num_palette_predictor_initializers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.luma_bit_depth_entry_minus8, "uint8_t", "luma_bit_depth_entry_minus8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.chroma_bit_depth_entry_minus8, "uint8_t", "chroma_bit_depth_entry_minus8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_tile_columns_minus1, "uint8_t", "num_tile_columns_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_tile_rows_minus1, "uint8_t", "num_tile_rows_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved2, "uint8_t", "reserved2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.column_width_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE, "uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]", "column_width_minus1", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.row_height_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE, "uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]", "row_height_minus1", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved3, "uint32_t", "reserved3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pScalingLists, "const StdVideoH265ScalingLists*", "pScalingLists", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ScalingLists);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pPredictorPaletteEntries, "const StdVideoH265PredictorPaletteEntries*", "pPredictorPaletteEntries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PredictorPaletteEntries);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH265PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeH265PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.IrapPicFlag, "uint32_t: 1", "IrapPicFlag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.IdrPicFlag, "uint32_t: 1", "IdrPicFlag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.IsReference, "uint32_t: 1", "IsReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.short_term_ref_pic_set_sps_flag, "uint32_t: 1", "short_term_ref_pic_set_sps_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH265PictureInfo(ApiDumpInstance& api_dump, const StdVideoDecodeH265PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeH265PictureInfoFlags(api_dump, object.flags, "StdVideoDecodeH265PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_video_parameter_set_id, "uint8_t", "sps_video_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_seq_parameter_set_id, "uint8_t", "pps_seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_pic_parameter_set_id, "uint8_t", "pps_pic_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.NumDeltaPocsOfRefRpsIdx, "uint8_t", "NumDeltaPocsOfRefRpsIdx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.PicOrderCntVal, "int32_t", "PicOrderCntVal", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.NumBitsForSTRefPicSetInSlice, "uint16_t", "NumBitsForSTRefPicSetInSlice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.reserved, "uint16_t", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicSetStCurrBefore, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetStCurrBefore", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicSetStCurrAfter, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetStCurrAfter", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicSetLtCurr, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetLtCurr", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH265ReferenceInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeH265ReferenceInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.used_for_long_term_reference, "uint32_t: 1", "used_for_long_term_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.unused_for_reference, "uint32_t: 1", "unused_for_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeH265ReferenceInfo(ApiDumpInstance& api_dump, const StdVideoDecodeH265ReferenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeH265ReferenceInfoFlags(api_dump, object.flags, "StdVideoDecodeH265ReferenceInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.PicOrderCntVal, "int32_t", "PicOrderCntVal", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265WeightTableFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH265WeightTableFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint16_t>(api_dump, object.luma_weight_l0_flag, "uint16_t", "luma_weight_l0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.chroma_weight_l0_flag, "uint16_t", "chroma_weight_l0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.luma_weight_l1_flag, "uint16_t", "luma_weight_l1_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.chroma_weight_l1_flag, "uint16_t", "chroma_weight_l1_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265WeightTable(ApiDumpInstance& api_dump, const StdVideoEncodeH265WeightTable& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH265WeightTableFlags(api_dump, object.flags, "StdVideoEncodeH265WeightTableFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.luma_log2_weight_denom, "uint8_t", "luma_log2_weight_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.delta_chroma_log2_weight_denom, "int8_t", "delta_chroma_log2_weight_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_luma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "delta_luma_weight_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.luma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "luma_offset_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.delta_chroma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_weight_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.delta_chroma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_offset_l0", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_luma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "delta_luma_weight_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.luma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "luma_offset_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.delta_chroma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_weight_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.delta_chroma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_offset_l1", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265SliceSegmentHeaderFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH265SliceSegmentHeaderFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.first_slice_segment_in_pic_flag, "uint32_t: 1", "first_slice_segment_in_pic_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dependent_slice_segment_flag, "uint32_t: 1", "dependent_slice_segment_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_sao_luma_flag, "uint32_t: 1", "slice_sao_luma_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_sao_chroma_flag, "uint32_t: 1", "slice_sao_chroma_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_active_override_flag, "uint32_t: 1", "num_ref_idx_active_override_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mvd_l1_zero_flag, "uint32_t: 1", "mvd_l1_zero_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cabac_init_flag, "uint32_t: 1", "cabac_init_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cu_chroma_qp_offset_enabled_flag, "uint32_t: 1", "cu_chroma_qp_offset_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deblocking_filter_override_flag, "uint32_t: 1", "deblocking_filter_override_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_deblocking_filter_disabled_flag, "uint32_t: 1", "slice_deblocking_filter_disabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.collocated_from_l0_flag, "uint32_t: 1", "collocated_from_l0_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_loop_filter_across_slices_enabled_flag, "uint32_t: 1", "slice_loop_filter_across_slices_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 20", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265SliceSegmentHeader(ApiDumpInstance& api_dump, const StdVideoEncodeH265SliceSegmentHeader& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH265SliceSegmentHeaderFlags(api_dump, object.flags, "StdVideoEncodeH265SliceSegmentHeaderFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265SliceType(api_dump, object.slice_type, "StdVideoH265SliceType", "slice_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_segment_address, "uint32_t", "slice_segment_address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.collocated_ref_idx, "uint8_t", "collocated_ref_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.MaxNumMergeCand, "uint8_t", "MaxNumMergeCand", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_cb_qp_offset, "int8_t", "slice_cb_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_cr_qp_offset, "int8_t", "slice_cr_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_beta_offset_div2, "int8_t", "slice_beta_offset_div2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_tc_offset_div2, "int8_t", "slice_tc_offset_div2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_act_y_qp_offset, "int8_t", "slice_act_y_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_act_cb_qp_offset, "int8_t", "slice_act_cb_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_act_cr_qp_offset, "int8_t", "slice_act_cr_qp_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slice_qp_delta, "int8_t", "slice_qp_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.reserved1, "uint16_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pWeightTable, "const StdVideoEncodeH265WeightTable*", "pWeightTable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265WeightTable);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265ReferenceListsInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH265ReferenceListsInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.ref_pic_list_modification_flag_l0, "uint32_t: 1", "ref_pic_list_modification_flag_l0", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.ref_pic_list_modification_flag_l1, "uint32_t: 1", "ref_pic_list_modification_flag_l1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265ReferenceListsInfo(ApiDumpInstance& api_dump, const StdVideoEncodeH265ReferenceListsInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH265ReferenceListsInfoFlags(api_dump, object.flags, "StdVideoEncodeH265ReferenceListsInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l0_active_minus1, "uint8_t", "num_ref_idx_l0_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ref_idx_l1_active_minus1, "uint8_t", "num_ref_idx_l1_active_minus1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicList0, STD_VIDEO_H265_MAX_NUM_LIST_REF, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "RefPicList0", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.RefPicList1, STD_VIDEO_H265_MAX_NUM_LIST_REF, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "RefPicList1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.list_entry_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "list_entry_l0", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.list_entry_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "list_entry_l1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH265PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.is_reference, "uint32_t: 1", "is_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.IrapPicFlag, "uint32_t: 1", "IrapPicFlag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.used_for_long_term_reference, "uint32_t: 1", "used_for_long_term_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.discardable_flag, "uint32_t: 1", "discardable_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cross_layer_bla_flag, "uint32_t: 1", "cross_layer_bla_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pic_output_flag, "uint32_t: 1", "pic_output_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.no_output_of_prior_pics_flag, "uint32_t: 1", "no_output_of_prior_pics_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.short_term_ref_pic_set_sps_flag, "uint32_t: 1", "short_term_ref_pic_set_sps_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.slice_temporal_mvp_enabled_flag, "uint32_t: 1", "slice_temporal_mvp_enabled_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 23", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265LongTermRefPics(ApiDumpInstance& api_dump, const StdVideoEncodeH265LongTermRefPics& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.num_long_term_sps, "uint8_t", "num_long_term_sps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_long_term_pics, "uint8_t", "num_long_term_pics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.lt_idx_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS, "uint8_t[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]", "lt_idx_sps", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.poc_lsb_lt, STD_VIDEO_H265_MAX_LONG_TERM_PICS, "uint8_t[STD_VIDEO_H265_MAX_LONG_TERM_PICS]", "poc_lsb_lt", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.used_by_curr_pic_lt_flag, "uint16_t", "used_by_curr_pic_lt_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_poc_msb_present_flag, STD_VIDEO_H265_MAX_DELTA_POC, "uint8_t[STD_VIDEO_H265_MAX_DELTA_POC]", "delta_poc_msb_present_flag", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_poc_msb_cycle_lt, STD_VIDEO_H265_MAX_DELTA_POC, "uint8_t[STD_VIDEO_H265_MAX_DELTA_POC]", "delta_poc_msb_cycle_lt", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265PictureInfo(ApiDumpInstance& api_dump, const StdVideoEncodeH265PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH265PictureInfoFlags(api_dump, object.flags, "StdVideoEncodeH265PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265PictureType(api_dump, object.pic_type, "StdVideoH265PictureType", "pic_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sps_video_parameter_set_id, "uint8_t", "sps_video_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_seq_parameter_set_id, "uint8_t", "pps_seq_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pps_pic_parameter_set_id, "uint8_t", "pps_pic_parameter_set_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.short_term_ref_pic_set_idx, "uint8_t", "short_term_ref_pic_set_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.PicOrderCntVal, "int32_t", "PicOrderCntVal", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.TemporalId, "uint8_t", "TemporalId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 7, "uint8_t[7]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pRefLists, "const StdVideoEncodeH265ReferenceListsInfo*", "pRefLists", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265ReferenceListsInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pShortTermRefPicSet, "const StdVideoH265ShortTermRefPicSet*", "pShortTermRefPicSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ShortTermRefPicSet);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLongTermRefPics, "const StdVideoEncodeH265LongTermRefPics*", "pLongTermRefPics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265LongTermRefPics);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265ReferenceInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeH265ReferenceInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.used_for_long_term_reference, "uint32_t: 1", "used_for_long_term_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.unused_for_reference, "uint32_t: 1", "unused_for_reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeH265ReferenceInfo(ApiDumpInstance& api_dump, const StdVideoEncodeH265ReferenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeH265ReferenceInfoFlags(api_dump, object.flags, "StdVideoEncodeH265ReferenceInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265PictureType(api_dump, object.pic_type, "StdVideoH265PictureType", "pic_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.PicOrderCntVal, "int32_t", "PicOrderCntVal", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.TemporalId, "uint8_t", "TemporalId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1ColorConfigFlags(ApiDumpInstance& api_dump, const StdVideoAV1ColorConfigFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.mono_chrome, "uint32_t: 1", "mono_chrome", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.color_range, "uint32_t: 1", "color_range", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.separate_uv_delta_q, "uint32_t: 1", "separate_uv_delta_q", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.color_description_present_flag, "uint32_t: 1", "color_description_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 28", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1ColorConfig(ApiDumpInstance& api_dump, const StdVideoAV1ColorConfig& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1ColorConfigFlags(api_dump, object.flags, "StdVideoAV1ColorConfigFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.BitDepth, "uint8_t", "BitDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subsampling_x, "uint8_t", "subsampling_x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subsampling_y, "uint8_t", "subsampling_y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1ColorPrimaries(api_dump, object.color_primaries, "StdVideoAV1ColorPrimaries", "color_primaries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1TransferCharacteristics(api_dump, object.transfer_characteristics, "StdVideoAV1TransferCharacteristics", "transfer_characteristics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1MatrixCoefficients(api_dump, object.matrix_coefficients, "StdVideoAV1MatrixCoefficients", "matrix_coefficients", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1ChromaSamplePosition(api_dump, object.chroma_sample_position, "StdVideoAV1ChromaSamplePosition", "chroma_sample_position", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1TimingInfoFlags(ApiDumpInstance& api_dump, const StdVideoAV1TimingInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.equal_picture_interval, "uint32_t: 1", "equal_picture_interval", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 31", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1TimingInfo(ApiDumpInstance& api_dump, const StdVideoAV1TimingInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1TimingInfoFlags(api_dump, object.flags, "StdVideoAV1TimingInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_units_in_display_tick, "uint32_t", "num_units_in_display_tick", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.time_scale, "uint32_t", "time_scale", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_ticks_per_picture_minus_1, "uint32_t", "num_ticks_per_picture_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1LoopFilterFlags(ApiDumpInstance& api_dump, const StdVideoAV1LoopFilterFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.loop_filter_delta_enabled, "uint32_t: 1", "loop_filter_delta_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.loop_filter_delta_update, "uint32_t: 1", "loop_filter_delta_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1LoopFilter(ApiDumpInstance& api_dump, const StdVideoAV1LoopFilter& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1LoopFilterFlags(api_dump, object.flags, "StdVideoAV1LoopFilterFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.loop_filter_level, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS, "uint8_t[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]", "loop_filter_level", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.loop_filter_sharpness, "uint8_t", "loop_filter_sharpness", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.update_ref_delta, "uint8_t", "update_ref_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.loop_filter_ref_deltas, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME, "int8_t[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]", "loop_filter_ref_deltas", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.update_mode_delta, "uint8_t", "update_mode_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.loop_filter_mode_deltas, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS, "int8_t[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]", "loop_filter_mode_deltas", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1QuantizationFlags(ApiDumpInstance& api_dump, const StdVideoAV1QuantizationFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.using_qmatrix, "uint32_t: 1", "using_qmatrix", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.diff_uv_delta, "uint32_t: 1", "diff_uv_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1Quantization(ApiDumpInstance& api_dump, const StdVideoAV1Quantization& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1QuantizationFlags(api_dump, object.flags, "StdVideoAV1QuantizationFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.base_q_idx, "uint8_t", "base_q_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.DeltaQYDc, "int8_t", "DeltaQYDc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.DeltaQUDc, "int8_t", "DeltaQUDc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.DeltaQUAc, "int8_t", "DeltaQUAc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.DeltaQVDc, "int8_t", "DeltaQVDc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.DeltaQVAc, "int8_t", "DeltaQVAc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.qm_y, "uint8_t", "qm_y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.qm_u, "uint8_t", "qm_u", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.qm_v, "uint8_t", "qm_v", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1Segmentation(ApiDumpInstance& api_dump, const StdVideoAV1Segmentation& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_single_array(api_dump, object.FeatureEnabled, STD_VIDEO_AV1_MAX_SEGMENTS, "uint8_t[STD_VIDEO_AV1_MAX_SEGMENTS]", "FeatureEnabled", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.FeatureData, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX, "int16_t[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]", "FeatureData", "int16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int16_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1TileInfoFlags(ApiDumpInstance& api_dump, const StdVideoAV1TileInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.uniform_tile_spacing_flag, "uint32_t: 1", "uniform_tile_spacing_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 31", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1TileInfo(ApiDumpInstance& api_dump, const StdVideoAV1TileInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1TileInfoFlags(api_dump, object.flags, "StdVideoAV1TileInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.TileCols, "uint8_t", "TileCols", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.TileRows, "uint8_t", "TileRows", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.context_update_tile_id, "uint16_t", "context_update_tile_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tile_size_bytes_minus_1, "uint8_t", "tile_size_bytes_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 7, "uint8_t[7]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pMiColStarts, object.TileCols, "const uint16_t*", "pMiColStarts", "const uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint16_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pMiRowStarts, object.TileRows, "const uint16_t*", "pMiRowStarts", "const uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint16_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWidthInSbsMinus1, object.TileCols, "const uint16_t*", "pWidthInSbsMinus1", "const uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint16_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pHeightInSbsMinus1, object.TileRows, "const uint16_t*", "pHeightInSbsMinus1", "const uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint16_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1CDEF(ApiDumpInstance& api_dump, const StdVideoAV1CDEF& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.cdef_damping_minus_3, "uint8_t", "cdef_damping_minus_3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cdef_bits, "uint8_t", "cdef_bits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cdef_y_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_y_pri_strength", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cdef_y_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_y_sec_strength", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cdef_uv_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_uv_pri_strength", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.cdef_uv_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_uv_sec_strength", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1LoopRestoration(ApiDumpInstance& api_dump, const StdVideoAV1LoopRestoration& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_single_array(api_dump, object.FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES, "StdVideoAV1FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]", "FrameRestorationType", "StdVideoAV1FrameRestorationType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1FrameRestorationType);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.LoopRestorationSize, STD_VIDEO_AV1_MAX_NUM_PLANES, "uint16_t[STD_VIDEO_AV1_MAX_NUM_PLANES]", "LoopRestorationSize", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1GlobalMotion(ApiDumpInstance& api_dump, const StdVideoAV1GlobalMotion& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_single_array(api_dump, object.GmType, STD_VIDEO_AV1_NUM_REF_FRAMES, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "GmType", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.gm_params, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS, "int32_t[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]", "gm_params", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1FilmGrainFlags(ApiDumpInstance& api_dump, const StdVideoAV1FilmGrainFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.chroma_scaling_from_luma, "uint32_t: 1", "chroma_scaling_from_luma", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.overlap_flag, "uint32_t: 1", "overlap_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clip_to_restricted_range, "uint32_t: 1", "clip_to_restricted_range", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.update_grain, "uint32_t: 1", "update_grain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 28", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1FilmGrain(ApiDumpInstance& api_dump, const StdVideoAV1FilmGrain& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1FilmGrainFlags(api_dump, object.flags, "StdVideoAV1FilmGrainFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.grain_scaling_minus_8, "uint8_t", "grain_scaling_minus_8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.ar_coeff_lag, "uint8_t", "ar_coeff_lag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.ar_coeff_shift_minus_6, "uint8_t", "ar_coeff_shift_minus_6", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.grain_scale_shift, "uint8_t", "grain_scale_shift", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.grain_seed, "uint16_t", "grain_seed", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.film_grain_params_ref_idx, "uint8_t", "film_grain_params_ref_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_y_points, "uint8_t", "num_y_points", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.point_y_value, STD_VIDEO_AV1_MAX_NUM_Y_POINTS, "uint8_t[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]", "point_y_value", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.point_y_scaling, STD_VIDEO_AV1_MAX_NUM_Y_POINTS, "uint8_t[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]", "point_y_scaling", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_cb_points, "uint8_t", "num_cb_points", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.point_cb_value, STD_VIDEO_AV1_MAX_NUM_CB_POINTS, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]", "point_cb_value", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.point_cb_scaling, STD_VIDEO_AV1_MAX_NUM_CB_POINTS, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]", "point_cb_scaling", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_cr_points, "uint8_t", "num_cr_points", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.point_cr_value, STD_VIDEO_AV1_MAX_NUM_CR_POINTS, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]", "point_cr_value", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.point_cr_scaling, STD_VIDEO_AV1_MAX_NUM_CR_POINTS, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]", "point_cr_scaling", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ar_coeffs_y_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_LUMA, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]", "ar_coeffs_y_plus_128", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ar_coeffs_cb_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]", "ar_coeffs_cb_plus_128", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ar_coeffs_cr_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]", "ar_coeffs_cr_plus_128", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cb_mult, "uint8_t", "cb_mult", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cb_luma_mult, "uint8_t", "cb_luma_mult", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.cb_offset, "uint16_t", "cb_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cr_mult, "uint8_t", "cr_mult", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cr_luma_mult, "uint8_t", "cr_luma_mult", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.cr_offset, "uint16_t", "cr_offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1SequenceHeaderFlags(ApiDumpInstance& api_dump, const StdVideoAV1SequenceHeaderFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.still_picture, "uint32_t: 1", "still_picture", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reduced_still_picture_header, "uint32_t: 1", "reduced_still_picture_header", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.use_128x128_superblock, "uint32_t: 1", "use_128x128_superblock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_filter_intra, "uint32_t: 1", "enable_filter_intra", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_intra_edge_filter, "uint32_t: 1", "enable_intra_edge_filter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_interintra_compound, "uint32_t: 1", "enable_interintra_compound", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_masked_compound, "uint32_t: 1", "enable_masked_compound", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_warped_motion, "uint32_t: 1", "enable_warped_motion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_dual_filter, "uint32_t: 1", "enable_dual_filter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_order_hint, "uint32_t: 1", "enable_order_hint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_jnt_comp, "uint32_t: 1", "enable_jnt_comp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_ref_frame_mvs, "uint32_t: 1", "enable_ref_frame_mvs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_id_numbers_present_flag, "uint32_t: 1", "frame_id_numbers_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_superres, "uint32_t: 1", "enable_superres", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_cdef, "uint32_t: 1", "enable_cdef", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enable_restoration, "uint32_t: 1", "enable_restoration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.film_grain_params_present, "uint32_t: 1", "film_grain_params_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.timing_info_present_flag, "uint32_t: 1", "timing_info_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.initial_display_delay_present_flag, "uint32_t: 1", "initial_display_delay_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 13", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoAV1SequenceHeader(ApiDumpInstance& api_dump, const StdVideoAV1SequenceHeader& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoAV1SequenceHeaderFlags(api_dump, object.flags, "StdVideoAV1SequenceHeaderFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1Profile(api_dump, object.seq_profile, "StdVideoAV1Profile", "seq_profile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_width_bits_minus_1, "uint8_t", "frame_width_bits_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_height_bits_minus_1, "uint8_t", "frame_height_bits_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.max_frame_width_minus_1, "uint16_t", "max_frame_width_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.max_frame_height_minus_1, "uint16_t", "max_frame_height_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_frame_id_length_minus_2, "uint8_t", "delta_frame_id_length_minus_2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.additional_frame_id_length_minus_1, "uint8_t", "additional_frame_id_length_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.order_hint_bits_minus_1, "uint8_t", "order_hint_bits_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_force_integer_mv, "uint8_t", "seq_force_integer_mv", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_force_screen_content_tools, "uint8_t", "seq_force_screen_content_tools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 5, "uint8_t[5]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pColorConfig, "const StdVideoAV1ColorConfig*", "pColorConfig", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1ColorConfig);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTimingInfo, "const StdVideoAV1TimingInfo*", "pTimingInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TimingInfo);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeAV1PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeAV1PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.error_resilient_mode, "uint32_t: 1", "error_resilient_mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.disable_cdf_update, "uint32_t: 1", "disable_cdf_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.use_superres, "uint32_t: 1", "use_superres", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.render_and_frame_size_different, "uint32_t: 1", "render_and_frame_size_different", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_screen_content_tools, "uint32_t: 1", "allow_screen_content_tools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_filter_switchable, "uint32_t: 1", "is_filter_switchable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.force_integer_mv, "uint32_t: 1", "force_integer_mv", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_size_override_flag, "uint32_t: 1", "frame_size_override_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.buffer_removal_time_present_flag, "uint32_t: 1", "buffer_removal_time_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_intrabc, "uint32_t: 1", "allow_intrabc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_refs_short_signaling, "uint32_t: 1", "frame_refs_short_signaling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_high_precision_mv, "uint32_t: 1", "allow_high_precision_mv", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_motion_mode_switchable, "uint32_t: 1", "is_motion_mode_switchable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.use_ref_frame_mvs, "uint32_t: 1", "use_ref_frame_mvs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.disable_frame_end_update_cdf, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_warped_motion, "uint32_t: 1", "allow_warped_motion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reduced_tx_set, "uint32_t: 1", "reduced_tx_set", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reference_select, "uint32_t: 1", "reference_select", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.skip_mode_present, "uint32_t: 1", "skip_mode_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_q_present, "uint32_t: 1", "delta_q_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_lf_present, "uint32_t: 1", "delta_lf_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_lf_multi, "uint32_t: 1", "delta_lf_multi", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_enabled, "uint32_t: 1", "segmentation_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_update_map, "uint32_t: 1", "segmentation_update_map", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_temporal_update, "uint32_t: 1", "segmentation_temporal_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_update_data, "uint32_t: 1", "segmentation_update_data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.UsesLr, "uint32_t: 1", "UsesLr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.usesChromaLr, "uint32_t: 1", "usesChromaLr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.apply_grain, "uint32_t: 1", "apply_grain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 3", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeAV1PictureInfo(ApiDumpInstance& api_dump, const StdVideoDecodeAV1PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeAV1PictureInfoFlags(api_dump, object.flags, "StdVideoDecodeAV1PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1FrameType(api_dump, object.frame_type, "StdVideoAV1FrameType", "frame_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.current_frame_id, "uint32_t", "current_frame_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.OrderHint, "uint8_t", "OrderHint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.primary_ref_frame, "uint8_t", "primary_ref_frame", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refresh_frame_flags, "uint8_t", "refresh_frame_flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1InterpolationFilter(api_dump, object.interpolation_filter, "StdVideoAV1InterpolationFilter", "interpolation_filter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1TxMode(api_dump, object.TxMode, "StdVideoAV1TxMode", "TxMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_q_res, "uint8_t", "delta_q_res", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_lf_res, "uint8_t", "delta_lf_res", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.SkipModeFrame, STD_VIDEO_AV1_SKIP_MODE_FRAMES, "uint8_t[STD_VIDEO_AV1_SKIP_MODE_FRAMES]", "SkipModeFrame", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.coded_denom, "uint8_t", "coded_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved2, 3, "uint8_t[3]", "reserved2", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.OrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "OrderHints", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.expectedFrameId, STD_VIDEO_AV1_NUM_REF_FRAMES, "uint32_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "expectedFrameId", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTileInfo, "const StdVideoAV1TileInfo*", "pTileInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TileInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pQuantization, "const StdVideoAV1Quantization*", "pQuantization", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Quantization);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSegmentation, "const StdVideoAV1Segmentation*", "pSegmentation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Segmentation);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLoopFilter, "const StdVideoAV1LoopFilter*", "pLoopFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopFilter);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCDEF, "const StdVideoAV1CDEF*", "pCDEF", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1CDEF);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLoopRestoration, "const StdVideoAV1LoopRestoration*", "pLoopRestoration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopRestoration);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pGlobalMotion, "const StdVideoAV1GlobalMotion*", "pGlobalMotion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1GlobalMotion);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pFilmGrain, "const StdVideoAV1FilmGrain*", "pFilmGrain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1FilmGrain);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeAV1ReferenceInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeAV1ReferenceInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.disable_frame_end_update_cdf, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_enabled, "uint32_t: 1", "segmentation_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeAV1ReferenceInfo(ApiDumpInstance& api_dump, const StdVideoDecodeAV1ReferenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeAV1ReferenceInfoFlags(api_dump, object.flags, "StdVideoDecodeAV1ReferenceInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_type, "uint8_t", "frame_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.RefFrameSignBias, "uint8_t", "RefFrameSignBias", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.OrderHint, "uint8_t", "OrderHint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.SavedOrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "SavedOrderHints", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1DecoderModelInfo(ApiDumpInstance& api_dump, const StdVideoEncodeAV1DecoderModelInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.buffer_delay_length_minus_1, "uint8_t", "buffer_delay_length_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.buffer_removal_time_length_minus_1, "uint8_t", "buffer_removal_time_length_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_presentation_time_length_minus_1, "uint8_t", "frame_presentation_time_length_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.num_units_in_decoding_tick, "uint32_t", "num_units_in_decoding_tick", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1ExtensionHeader(ApiDumpInstance& api_dump, const StdVideoEncodeAV1ExtensionHeader& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.temporal_id, "uint8_t", "temporal_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.spatial_id, "uint8_t", "spatial_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1OperatingPointInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeAV1OperatingPointInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.decoder_model_present_for_this_op, "uint32_t: 1", "decoder_model_present_for_this_op", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.low_delay_mode_flag, "uint32_t: 1", "low_delay_mode_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.initial_display_delay_present_for_this_op, "uint32_t: 1", "initial_display_delay_present_for_this_op", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 29", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1OperatingPointInfo(ApiDumpInstance& api_dump, const StdVideoEncodeAV1OperatingPointInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeAV1OperatingPointInfoFlags(api_dump, object.flags, "StdVideoEncodeAV1OperatingPointInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.operating_point_idc, "uint16_t", "operating_point_idc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_level_idx, "uint8_t", "seq_level_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.seq_tier, "uint8_t", "seq_tier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.decoder_buffer_delay, "uint32_t", "decoder_buffer_delay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.encoder_buffer_delay, "uint32_t", "encoder_buffer_delay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.initial_display_delay_minus_1, "uint8_t", "initial_display_delay_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeAV1PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.error_resilient_mode, "uint32_t: 1", "error_resilient_mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.disable_cdf_update, "uint32_t: 1", "disable_cdf_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.use_superres, "uint32_t: 1", "use_superres", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.render_and_frame_size_different, "uint32_t: 1", "render_and_frame_size_different", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_screen_content_tools, "uint32_t: 1", "allow_screen_content_tools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_filter_switchable, "uint32_t: 1", "is_filter_switchable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.force_integer_mv, "uint32_t: 1", "force_integer_mv", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_size_override_flag, "uint32_t: 1", "frame_size_override_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.buffer_removal_time_present_flag, "uint32_t: 1", "buffer_removal_time_present_flag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_intrabc, "uint32_t: 1", "allow_intrabc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_refs_short_signaling, "uint32_t: 1", "frame_refs_short_signaling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_high_precision_mv, "uint32_t: 1", "allow_high_precision_mv", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.is_motion_mode_switchable, "uint32_t: 1", "is_motion_mode_switchable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.use_ref_frame_mvs, "uint32_t: 1", "use_ref_frame_mvs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.disable_frame_end_update_cdf, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_warped_motion, "uint32_t: 1", "allow_warped_motion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reduced_tx_set, "uint32_t: 1", "reduced_tx_set", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.skip_mode_present, "uint32_t: 1", "skip_mode_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_q_present, "uint32_t: 1", "delta_q_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_lf_present, "uint32_t: 1", "delta_lf_present", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_lf_multi, "uint32_t: 1", "delta_lf_multi", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_enabled, "uint32_t: 1", "segmentation_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_update_map, "uint32_t: 1", "segmentation_update_map", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_temporal_update, "uint32_t: 1", "segmentation_temporal_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_update_data, "uint32_t: 1", "segmentation_update_data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.UsesLr, "uint32_t: 1", "UsesLr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.usesChromaLr, "uint32_t: 1", "usesChromaLr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.show_frame, "uint32_t: 1", "show_frame", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.showable_frame, "uint32_t: 1", "showable_frame", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 3", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1PictureInfo(ApiDumpInstance& api_dump, const StdVideoEncodeAV1PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeAV1PictureInfoFlags(api_dump, object.flags, "StdVideoEncodeAV1PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1FrameType(api_dump, object.frame_type, "StdVideoAV1FrameType", "frame_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_presentation_time, "uint32_t", "frame_presentation_time", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.current_frame_id, "uint32_t", "current_frame_id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.order_hint, "uint8_t", "order_hint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.primary_ref_frame, "uint8_t", "primary_ref_frame", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refresh_frame_flags, "uint8_t", "refresh_frame_flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.coded_denom, "uint8_t", "coded_denom", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.render_width_minus_1, "uint16_t", "render_width_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.render_height_minus_1, "uint16_t", "render_height_minus_1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1InterpolationFilter(api_dump, object.interpolation_filter, "StdVideoAV1InterpolationFilter", "interpolation_filter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1TxMode(api_dump, object.TxMode, "StdVideoAV1TxMode", "TxMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_q_res, "uint8_t", "delta_q_res", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.delta_lf_res, "uint8_t", "delta_lf_res", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "ref_order_hint", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME, "int8_t[STD_VIDEO_AV1_REFS_PER_FRAME]", "ref_frame_idx", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 3, "uint8_t[3]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME, "uint32_t[STD_VIDEO_AV1_REFS_PER_FRAME]", "delta_frame_id_minus_1", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTileInfo, "const StdVideoAV1TileInfo*", "pTileInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TileInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pQuantization, "const StdVideoAV1Quantization*", "pQuantization", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Quantization);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSegmentation, "const StdVideoAV1Segmentation*", "pSegmentation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Segmentation);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLoopFilter, "const StdVideoAV1LoopFilter*", "pLoopFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopFilter);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCDEF, "const StdVideoAV1CDEF*", "pCDEF", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1CDEF);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLoopRestoration, "const StdVideoAV1LoopRestoration*", "pLoopRestoration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopRestoration);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pGlobalMotion, "const StdVideoAV1GlobalMotion*", "pGlobalMotion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1GlobalMotion);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pExtensionHeader, "const StdVideoEncodeAV1ExtensionHeader*", "pExtensionHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ExtensionHeader);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pBufferRemovalTimes, "const uint32_t*", "pBufferRemovalTimes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1ReferenceInfoFlags(ApiDumpInstance& api_dump, const StdVideoEncodeAV1ReferenceInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.disable_frame_end_update_cdf, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_enabled, "uint32_t: 1", "segmentation_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoEncodeAV1ReferenceInfo(ApiDumpInstance& api_dump, const StdVideoEncodeAV1ReferenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoEncodeAV1ReferenceInfoFlags(api_dump, object.flags, "StdVideoEncodeAV1ReferenceInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.RefFrameId, "uint32_t", "RefFrameId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1FrameType(api_dump, object.frame_type, "StdVideoAV1FrameType", "frame_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.OrderHint, "uint8_t", "OrderHint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 3, "uint8_t[3]", "reserved1", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pExtensionHeader, "const StdVideoEncodeAV1ExtensionHeader*", "pExtensionHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ExtensionHeader);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoVP9ColorConfigFlags(ApiDumpInstance& api_dump, const StdVideoVP9ColorConfigFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.color_range, "uint32_t: 1", "color_range", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 31", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoVP9ColorConfig(ApiDumpInstance& api_dump, const StdVideoVP9ColorConfig& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoVP9ColorConfigFlags(api_dump, object.flags, "StdVideoVP9ColorConfigFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.BitDepth, "uint8_t", "BitDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subsampling_x, "uint8_t", "subsampling_x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subsampling_y, "uint8_t", "subsampling_y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved1, "uint8_t", "reserved1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoVP9ColorSpace(api_dump, object.color_space, "StdVideoVP9ColorSpace", "color_space", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoVP9LoopFilterFlags(ApiDumpInstance& api_dump, const StdVideoVP9LoopFilterFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.loop_filter_delta_enabled, "uint32_t: 1", "loop_filter_delta_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.loop_filter_delta_update, "uint32_t: 1", "loop_filter_delta_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 30", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoVP9LoopFilter(ApiDumpInstance& api_dump, const StdVideoVP9LoopFilter& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoVP9LoopFilterFlags(api_dump, object.flags, "StdVideoVP9LoopFilterFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.loop_filter_level, "uint8_t", "loop_filter_level", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.loop_filter_sharpness, "uint8_t", "loop_filter_sharpness", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.update_ref_delta, "uint8_t", "update_ref_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.loop_filter_ref_deltas, STD_VIDEO_VP9_MAX_REF_FRAMES, "int8_t[STD_VIDEO_VP9_MAX_REF_FRAMES]", "loop_filter_ref_deltas", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.update_mode_delta, "uint8_t", "update_mode_delta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.loop_filter_mode_deltas, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS, "int8_t[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS]", "loop_filter_mode_deltas", "int8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoVP9SegmentationFlags(ApiDumpInstance& api_dump, const StdVideoVP9SegmentationFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.segmentation_update_map, "uint32_t: 1", "segmentation_update_map", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_temporal_update, "uint32_t: 1", "segmentation_temporal_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_update_data, "uint32_t: 1", "segmentation_update_data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_abs_or_delta_update, "uint32_t: 1", "segmentation_abs_or_delta_update", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 28", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoVP9Segmentation(ApiDumpInstance& api_dump, const StdVideoVP9Segmentation& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoVP9SegmentationFlags(api_dump, object.flags, "StdVideoVP9SegmentationFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.segmentation_tree_probs, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS]", "segmentation_tree_probs", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.segmentation_pred_prob, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB]", "segmentation_pred_prob", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.FeatureEnabled, STD_VIDEO_VP9_MAX_SEGMENTS, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTS]", "FeatureEnabled", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_double_array(api_dump, object.FeatureData, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX, "int16_t[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX]", "FeatureData", "int16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int16_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeVP9PictureInfoFlags(ApiDumpInstance& api_dump, const StdVideoDecodeVP9PictureInfoFlags& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.error_resilient_mode, "uint32_t: 1", "error_resilient_mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intra_only, "uint32_t: 1", "intra_only", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.allow_high_precision_mv, "uint32_t: 1", "allow_high_precision_mv", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refresh_frame_context, "uint32_t: 1", "refresh_frame_context", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_parallel_decoding_mode, "uint32_t: 1", "frame_parallel_decoding_mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.segmentation_enabled, "uint32_t: 1", "segmentation_enabled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.show_frame, "uint32_t: 1", "show_frame", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.UsePrevFrameMvs, "uint32_t: 1", "UsePrevFrameMvs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t: 24", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_StdVideoDecodeVP9PictureInfo(ApiDumpInstance& api_dump, const StdVideoDecodeVP9PictureInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_StdVideoDecodeVP9PictureInfoFlags(api_dump, object.flags, "StdVideoDecodeVP9PictureInfoFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoVP9Profile(api_dump, object.profile, "StdVideoVP9Profile", "profile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoVP9FrameType(api_dump, object.frame_type, "StdVideoVP9FrameType", "frame_type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frame_context_idx, "uint8_t", "frame_context_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reset_frame_context, "uint8_t", "reset_frame_context", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refresh_frame_flags, "uint8_t", "refresh_frame_flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.ref_frame_sign_bias_mask, "uint8_t", "ref_frame_sign_bias_mask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoVP9InterpolationFilter(api_dump, object.interpolation_filter, "StdVideoVP9InterpolationFilter", "interpolation_filter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.base_q_idx, "uint8_t", "base_q_idx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.delta_q_y_dc, "int8_t", "delta_q_y_dc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.delta_q_uv_dc, "int8_t", "delta_q_uv_dc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.delta_q_uv_ac, "int8_t", "delta_q_uv_ac", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tile_cols_log2, "uint8_t", "tile_cols_log2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tile_rows_log2, "uint8_t", "tile_rows_log2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.reserved1, 3, "uint16_t[3]", "reserved1", "uint16_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint16_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pColorConfig, "const StdVideoVP9ColorConfig*", "pColorConfig", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9ColorConfig);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLoopFilter, "const StdVideoVP9LoopFilter*", "pLoopFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9LoopFilter);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSegmentation, "const StdVideoVP9Segmentation*", "pSegmentation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9Segmentation);
+    dump_end(api_dump, 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_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_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_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_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_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_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_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_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_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_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_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);
+void dump_VkExtent2D(ApiDumpInstance& api_dump, const VkExtent2D& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExtent3D(ApiDumpInstance& api_dump, const VkExtent3D& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.depth, "uint32_t", "depth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOffset2D(ApiDumpInstance& api_dump, const VkOffset2D& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<int32_t>(api_dump, object.x, "int32_t", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.y, "int32_t", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOffset3D(ApiDumpInstance& api_dump, const VkOffset3D& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<int32_t>(api_dump, object.x, "int32_t", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.y, "int32_t", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.z, "int32_t", "z", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRect2D(ApiDumpInstance& api_dump, const VkRect2D& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkOffset2D(api_dump, object.offset, "VkOffset2D", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.extent, "VkExtent2D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBaseInStructure(ApiDumpInstance& api_dump, const VkBaseInStructure& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pNext, "const struct VkBaseInStructure*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBaseInStructure);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBaseOutStructure(ApiDumpInstance& api_dump, const VkBaseOutStructure& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pNext, "struct VkBaseOutStructure*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBaseOutStructure);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferMemoryBarrier(ApiDumpInstance& api_dump, const VkBufferMemoryBarrier& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.srcAccessMask, "VkAccessFlags", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.dstAccessMask, "VkAccessFlags", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcQueueFamilyIndex, "uint32_t", "srcQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstQueueFamilyIndex, "uint32_t", "dstQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageSubresourceRange(ApiDumpInstance& api_dump, const VkImageSubresourceRange& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseMipLevel, "uint32_t", "baseMipLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.levelCount, "uint32_t", "levelCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseArrayLayer, "uint32_t", "baseArrayLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layerCount, "uint32_t", "layerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageMemoryBarrier(ApiDumpInstance& api_dump, const VkImageMemoryBarrier& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.srcAccessMask, "VkAccessFlags", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.dstAccessMask, "VkAccessFlags", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.oldLayout, "VkImageLayout", "oldLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.newLayout, "VkImageLayout", "newLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcQueueFamilyIndex, "uint32_t", "srcQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstQueueFamilyIndex, "uint32_t", "dstQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceRange(api_dump, object.subresourceRange, "VkImageSubresourceRange", "subresourceRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryBarrier(ApiDumpInstance& api_dump, const VkMemoryBarrier& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.srcAccessMask, "VkAccessFlags", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.dstAccessMask, "VkAccessFlags", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAllocationCallbacks(ApiDumpInstance& api_dump, const VkAllocationCallbacks& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<void*>(api_dump, object.pUserData, "void*", "pUserData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkAllocationFunction(api_dump, object.pfnAllocation, "PFN_vkAllocationFunction", "pfnAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkReallocationFunction(api_dump, object.pfnReallocation, "PFN_vkReallocationFunction", "pfnReallocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkFreeFunction(api_dump, object.pfnFree, "PFN_vkFreeFunction", "pfnFree", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkInternalAllocationNotification(api_dump, object.pfnInternalAllocation, "PFN_vkInternalAllocationNotification", "pfnInternalAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkInternalFreeNotification(api_dump, object.pfnInternalFree, "PFN_vkInternalFreeNotification", "pfnInternalFree", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkApplicationInfo(ApiDumpInstance& api_dump, const VkApplicationInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pApplicationName, "const char*", "pApplicationName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.applicationVersion, "uint32_t", "applicationVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pEngineName, "const char*", "pEngineName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.engineVersion, "uint32_t", "engineVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_api_version(api_dump, object.apiVersion, "uint32_t", "apiVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFormatProperties(ApiDumpInstance& api_dump, const VkFormatProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkFormatFeatureFlags(api_dump, object.linearTilingFeatures, "VkFormatFeatureFlags", "linearTilingFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.optimalTilingFeatures, "VkFormatFeatureFlags", "optimalTilingFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.bufferFeatures, "VkFormatFeatureFlags", "bufferFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageFormatProperties(ApiDumpInstance& api_dump, const VkImageFormatProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkExtent3D(api_dump, object.maxExtent, "VkExtent3D", "maxExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMipLevels, "uint32_t", "maxMipLevels", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxArrayLayers, "uint32_t", "maxArrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampleCounts, "VkSampleCountFlags", "sampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxResourceSize, "VkDeviceSize", "maxResourceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkInstanceCreateInfo(ApiDumpInstance& api_dump, const VkInstanceCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkInstanceCreateFlags(api_dump, object.flags, "VkInstanceCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pApplicationInfo, "const VkApplicationInfo*", "pApplicationInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkApplicationInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enabledLayerCount, "uint32_t", "enabledLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.ppEnabledLayerNames, object.enabledLayerCount, "const char* const*", "ppEnabledLayerNames", "const char*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_char);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enabledExtensionCount, "uint32_t", "enabledExtensionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.ppEnabledExtensionNames, object.enabledExtensionCount, "const char* const*", "ppEnabledExtensionNames", "const char*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_char);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryHeap(ApiDumpInstance& api_dump, const VkMemoryHeap& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryHeapFlags(api_dump, object.flags, "VkMemoryHeapFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryType(ApiDumpInstance& api_dump, const VkMemoryType& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkMemoryPropertyFlags(api_dump, object.propertyFlags, "VkMemoryPropertyFlags", "propertyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapIndex, "uint32_t", "heapIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkBool32>(api_dump, object.robustBufferAccess, "VkBool32", "robustBufferAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fullDrawIndexUint32, "VkBool32", "fullDrawIndexUint32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageCubeArray, "VkBool32", "imageCubeArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.independentBlend, "VkBool32", "independentBlend", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.geometryShader, "VkBool32", "geometryShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tessellationShader, "VkBool32", "tessellationShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sampleRateShading, "VkBool32", "sampleRateShading", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dualSrcBlend, "VkBool32", "dualSrcBlend", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.logicOp, "VkBool32", "logicOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiDrawIndirect, "VkBool32", "multiDrawIndirect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.drawIndirectFirstInstance, "VkBool32", "drawIndirectFirstInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClamp, "VkBool32", "depthClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBiasClamp, "VkBool32", "depthBiasClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fillModeNonSolid, "VkBool32", "fillModeNonSolid", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBounds, "VkBool32", "depthBounds", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.wideLines, "VkBool32", "wideLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.largePoints, "VkBool32", "largePoints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.alphaToOne, "VkBool32", "alphaToOne", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiViewport, "VkBool32", "multiViewport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.samplerAnisotropy, "VkBool32", "samplerAnisotropy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureCompressionETC2, "VkBool32", "textureCompressionETC2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureCompressionASTC_LDR, "VkBool32", "textureCompressionASTC_LDR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureCompressionBC, "VkBool32", "textureCompressionBC", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.occlusionQueryPrecise, "VkBool32", "occlusionQueryPrecise", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineStatisticsQuery, "VkBool32", "pipelineStatisticsQuery", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexPipelineStoresAndAtomics, "VkBool32", "vertexPipelineStoresAndAtomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentStoresAndAtomics, "VkBool32", "fragmentStoresAndAtomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTessellationAndGeometryPointSize, "VkBool32", "shaderTessellationAndGeometryPointSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderImageGatherExtended, "VkBool32", "shaderImageGatherExtended", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageExtendedFormats, "VkBool32", "shaderStorageImageExtendedFormats", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageMultisample, "VkBool32", "shaderStorageImageMultisample", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageReadWithoutFormat, "VkBool32", "shaderStorageImageReadWithoutFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageWriteWithoutFormat, "VkBool32", "shaderStorageImageWriteWithoutFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformBufferArrayDynamicIndexing, "VkBool32", "shaderUniformBufferArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSampledImageArrayDynamicIndexing, "VkBool32", "shaderSampledImageArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageBufferArrayDynamicIndexing, "VkBool32", "shaderStorageBufferArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageArrayDynamicIndexing, "VkBool32", "shaderStorageImageArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderClipDistance, "VkBool32", "shaderClipDistance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderCullDistance, "VkBool32", "shaderCullDistance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloat64, "VkBool32", "shaderFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInt64, "VkBool32", "shaderInt64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInt16, "VkBool32", "shaderInt16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderResourceResidency, "VkBool32", "shaderResourceResidency", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderResourceMinLod, "VkBool32", "shaderResourceMinLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseBinding, "VkBool32", "sparseBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidencyBuffer, "VkBool32", "sparseResidencyBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidencyImage2D, "VkBool32", "sparseResidencyImage2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidencyImage3D, "VkBool32", "sparseResidencyImage3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidency2Samples, "VkBool32", "sparseResidency2Samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidency4Samples, "VkBool32", "sparseResidency4Samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidency8Samples, "VkBool32", "sparseResidency8Samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidency16Samples, "VkBool32", "sparseResidency16Samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseResidencyAliased, "VkBool32", "sparseResidencyAliased", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.variableMultisampleRate, "VkBool32", "variableMultisampleRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.inheritedQueries, "VkBool32", "inheritedQueries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLimits(ApiDumpInstance& api_dump, const VkPhysicalDeviceLimits& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.maxImageDimension1D, "uint32_t", "maxImageDimension1D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageDimension2D, "uint32_t", "maxImageDimension2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageDimension3D, "uint32_t", "maxImageDimension3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageDimensionCube, "uint32_t", "maxImageDimensionCube", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageArrayLayers, "uint32_t", "maxImageArrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTexelBufferElements, "uint32_t", "maxTexelBufferElements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxUniformBufferRange, "uint32_t", "maxUniformBufferRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStorageBufferRange, "uint32_t", "maxStorageBufferRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPushConstantsSize, "uint32_t", "maxPushConstantsSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMemoryAllocationCount, "uint32_t", "maxMemoryAllocationCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSamplerAllocationCount, "uint32_t", "maxSamplerAllocationCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.bufferImageGranularity, "VkDeviceSize", "bufferImageGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.sparseAddressSpaceSize, "VkDeviceSize", "sparseAddressSpaceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBoundDescriptorSets, "uint32_t", "maxBoundDescriptorSets", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorSamplers, "uint32_t", "maxPerStageDescriptorSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUniformBuffers, "uint32_t", "maxPerStageDescriptorUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorStorageBuffers, "uint32_t", "maxPerStageDescriptorStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorSampledImages, "uint32_t", "maxPerStageDescriptorSampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorStorageImages, "uint32_t", "maxPerStageDescriptorStorageImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorInputAttachments, "uint32_t", "maxPerStageDescriptorInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageResources, "uint32_t", "maxPerStageResources", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetSamplers, "uint32_t", "maxDescriptorSetSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUniformBuffers, "uint32_t", "maxDescriptorSetUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUniformBuffersDynamic, "uint32_t", "maxDescriptorSetUniformBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetStorageBuffers, "uint32_t", "maxDescriptorSetStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetStorageBuffersDynamic, "uint32_t", "maxDescriptorSetStorageBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetSampledImages, "uint32_t", "maxDescriptorSetSampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetStorageImages, "uint32_t", "maxDescriptorSetStorageImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetInputAttachments, "uint32_t", "maxDescriptorSetInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexInputAttributes, "uint32_t", "maxVertexInputAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexInputBindings, "uint32_t", "maxVertexInputBindings", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexInputAttributeOffset, "uint32_t", "maxVertexInputAttributeOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexInputBindingStride, "uint32_t", "maxVertexInputBindingStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexOutputComponents, "uint32_t", "maxVertexOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationGenerationLevel, "uint32_t", "maxTessellationGenerationLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationPatchSize, "uint32_t", "maxTessellationPatchSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationControlPerVertexInputComponents, "uint32_t", "maxTessellationControlPerVertexInputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationControlPerVertexOutputComponents, "uint32_t", "maxTessellationControlPerVertexOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationControlPerPatchOutputComponents, "uint32_t", "maxTessellationControlPerPatchOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationControlTotalOutputComponents, "uint32_t", "maxTessellationControlTotalOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationEvaluationInputComponents, "uint32_t", "maxTessellationEvaluationInputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTessellationEvaluationOutputComponents, "uint32_t", "maxTessellationEvaluationOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryShaderInvocations, "uint32_t", "maxGeometryShaderInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryInputComponents, "uint32_t", "maxGeometryInputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryOutputComponents, "uint32_t", "maxGeometryOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryOutputVertices, "uint32_t", "maxGeometryOutputVertices", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryTotalOutputComponents, "uint32_t", "maxGeometryTotalOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentInputComponents, "uint32_t", "maxFragmentInputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentOutputAttachments, "uint32_t", "maxFragmentOutputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentDualSrcAttachments, "uint32_t", "maxFragmentDualSrcAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentCombinedOutputResources, "uint32_t", "maxFragmentCombinedOutputResources", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxComputeSharedMemorySize, "uint32_t", "maxComputeSharedMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxComputeWorkGroupCount, 3, "uint32_t[3]", "maxComputeWorkGroupCount", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxComputeWorkGroupInvocations, "uint32_t", "maxComputeWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxComputeWorkGroupSize, 3, "uint32_t[3]", "maxComputeWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subPixelPrecisionBits, "uint32_t", "subPixelPrecisionBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subTexelPrecisionBits, "uint32_t", "subTexelPrecisionBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mipmapPrecisionBits, "uint32_t", "mipmapPrecisionBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDrawIndexedIndexValue, "uint32_t", "maxDrawIndexedIndexValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDrawIndirectCount, "uint32_t", "maxDrawIndirectCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxSamplerLodBias, "float", "maxSamplerLodBias", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxSamplerAnisotropy, "float", "maxSamplerAnisotropy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxViewports, "uint32_t", "maxViewports", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxViewportDimensions, 2, "uint32_t[2]", "maxViewportDimensions", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.viewportBoundsRange, 2, "float[2]", "viewportBoundsRange", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewportSubPixelBits, "uint32_t", "viewportSubPixelBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.minMemoryMapAlignment, "size_t", "minMemoryMapAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minTexelBufferOffsetAlignment, "VkDeviceSize", "minTexelBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minUniformBufferOffsetAlignment, "VkDeviceSize", "minUniformBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minStorageBufferOffsetAlignment, "VkDeviceSize", "minStorageBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minTexelOffset, "int32_t", "minTexelOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTexelOffset, "uint32_t", "maxTexelOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minTexelGatherOffset, "int32_t", "minTexelGatherOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTexelGatherOffset, "uint32_t", "maxTexelGatherOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minInterpolationOffset, "float", "minInterpolationOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxInterpolationOffset, "float", "maxInterpolationOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subPixelInterpolationOffsetBits, "uint32_t", "subPixelInterpolationOffsetBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFramebufferWidth, "uint32_t", "maxFramebufferWidth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFramebufferHeight, "uint32_t", "maxFramebufferHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFramebufferLayers, "uint32_t", "maxFramebufferLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.framebufferColorSampleCounts, "VkSampleCountFlags", "framebufferColorSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.framebufferDepthSampleCounts, "VkSampleCountFlags", "framebufferDepthSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.framebufferStencilSampleCounts, "VkSampleCountFlags", "framebufferStencilSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.framebufferNoAttachmentsSampleCounts, "VkSampleCountFlags", "framebufferNoAttachmentsSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxColorAttachments, "uint32_t", "maxColorAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampledImageColorSampleCounts, "VkSampleCountFlags", "sampledImageColorSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampledImageIntegerSampleCounts, "VkSampleCountFlags", "sampledImageIntegerSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampledImageDepthSampleCounts, "VkSampleCountFlags", "sampledImageDepthSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampledImageStencilSampleCounts, "VkSampleCountFlags", "sampledImageStencilSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.storageImageSampleCounts, "VkSampleCountFlags", "storageImageSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSampleMaskWords, "uint32_t", "maxSampleMaskWords", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.timestampComputeAndGraphics, "VkBool32", "timestampComputeAndGraphics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.timestampPeriod, "float", "timestampPeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxClipDistances, "uint32_t", "maxClipDistances", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCullDistances, "uint32_t", "maxCullDistances", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCombinedClipAndCullDistances, "uint32_t", "maxCombinedClipAndCullDistances", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.discreteQueuePriorities, "uint32_t", "discreteQueuePriorities", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.pointSizeRange, 2, "float[2]", "pointSizeRange", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.lineWidthRange, 2, "float[2]", "lineWidthRange", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.pointSizeGranularity, "float", "pointSizeGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.lineWidthGranularity, "float", "lineWidthGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.strictLines, "VkBool32", "strictLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.standardSampleLocations, "VkBool32", "standardSampleLocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.optimalBufferCopyOffsetAlignment, "VkDeviceSize", "optimalBufferCopyOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.optimalBufferCopyRowPitchAlignment, "VkDeviceSize", "optimalBufferCopyRowPitchAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.nonCoherentAtomSize, "VkDeviceSize", "nonCoherentAtomSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMemoryProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceMemoryProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.memoryTypeCount, "uint32_t", "memoryTypeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.memoryTypes, std::min(object.memoryTypeCount, VK_MAX_MEMORY_TYPES), "VkMemoryType[VK_MAX_MEMORY_TYPES]", "memoryTypes", "VkMemoryType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryType);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryHeapCount, "uint32_t", "memoryHeapCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.memoryHeaps, std::min(object.memoryHeapCount, VK_MAX_MEMORY_HEAPS), "VkMemoryHeap[VK_MAX_MEMORY_HEAPS]", "memoryHeaps", "VkMemoryHeap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryHeap);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSparseProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceSparseProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkBool32>(api_dump, object.residencyStandard2DBlockShape, "VkBool32", "residencyStandard2DBlockShape", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.residencyStandard2DMultisampleBlockShape, "VkBool32", "residencyStandard2DMultisampleBlockShape", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.residencyStandard3DBlockShape, "VkBool32", "residencyStandard3DBlockShape", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.residencyAlignedMipSize, "VkBool32", "residencyAlignedMipSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.residencyNonResidentStrict, "VkBool32", "residencyNonResidentStrict", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_api_version(api_dump, object.apiVersion, "uint32_t", "apiVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.driverVersion, "uint32_t", "driverVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vendorID, "uint32_t", "vendorID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceID, "uint32_t", "deviceID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceType(api_dump, object.deviceType, "VkPhysicalDeviceType", "deviceType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.deviceName, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.pipelineCacheUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceLimits(api_dump, object.limits, "VkPhysicalDeviceLimits", "limits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceSparseProperties(api_dump, object.sparseProperties, "VkPhysicalDeviceSparseProperties", "sparseProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyProperties(ApiDumpInstance& api_dump, const VkQueueFamilyProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkQueueFlags(api_dump, object.queueFlags, "VkQueueFlags", "queueFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueCount, "uint32_t", "queueCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.timestampValidBits, "uint32_t", "timestampValidBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.minImageTransferGranularity, "VkExtent3D", "minImageTransferGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceQueueCreateInfo(ApiDumpInstance& api_dump, const VkDeviceQueueCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceQueueCreateFlags(api_dump, object.flags, "VkDeviceQueueCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndex, "uint32_t", "queueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueCount, "uint32_t", "queueCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pQueuePriorities, object.queueCount, "const float*", "pQueuePriorities", "const float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const float>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceCreateInfo(ApiDumpInstance& api_dump, const VkDeviceCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceCreateFlags(api_dump, object.flags, "VkDeviceCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueCreateInfoCount, "uint32_t", "queueCreateInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pQueueCreateInfos, object.queueCreateInfoCount, "const VkDeviceQueueCreateInfo*", "pQueueCreateInfos", "const VkDeviceQueueCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceQueueCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enabledLayerCount, "uint32_t", "enabledLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.ppEnabledLayerNames, object.enabledLayerCount, "const char* const*", "ppEnabledLayerNames", "const char*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_char);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enabledExtensionCount, "uint32_t", "enabledExtensionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.ppEnabledExtensionNames, object.enabledExtensionCount, "const char* const*", "ppEnabledExtensionNames", "const char*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_char);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pEnabledFeatures, "const VkPhysicalDeviceFeatures*", "pEnabledFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceFeatures);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExtensionProperties(ApiDumpInstance& api_dump, const VkExtensionProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_char(api_dump, object.extensionName, "char[VK_MAX_EXTENSION_NAME_SIZE]", "extensionName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.specVersion, "uint32_t", "specVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLayerProperties(ApiDumpInstance& api_dump, const VkLayerProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_char(api_dump, object.layerName, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layerName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.specVersion, "uint32_t", "specVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.implementationVersion, "uint32_t", "implementationVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubmitInfo(ApiDumpInstance& api_dump, const VkSubmitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreCount, "uint32_t", "waitSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphores, object.waitSemaphoreCount, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitDstStageMask, object.waitSemaphoreCount, "const VkPipelineStageFlags*", "pWaitDstStageMask", "const VkPipelineStageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineStageFlags);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.commandBufferCount, "uint32_t", "commandBufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCommandBuffers, object.commandBufferCount, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBuffer);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.signalSemaphoreCount, "uint32_t", "signalSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSignalSemaphores, object.signalSemaphoreCount, "const VkSemaphore*", "pSignalSemaphores", "const VkSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMappedMemoryRange(ApiDumpInstance& api_dump, const VkMappedMemoryRange& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryAllocateInfo(ApiDumpInstance& api_dump, const VkMemoryAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.allocationSize, "VkDeviceSize", "allocationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeIndex, "uint32_t", "memoryTypeIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryRequirements(ApiDumpInstance& api_dump, const VkMemoryRequirements& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.alignment, "VkDeviceSize", "alignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseMemoryBind(ApiDumpInstance& api_dump, const VkSparseMemoryBind& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkDeviceSize>(api_dump, object.resourceOffset, "VkDeviceSize", "resourceOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSparseMemoryBindFlags(api_dump, object.flags, "VkSparseMemoryBindFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseBufferMemoryBindInfo(ApiDumpInstance& api_dump, const VkSparseBufferMemoryBindInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bindCount, "uint32_t", "bindCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBinds, object.bindCount, "const VkSparseMemoryBind*", "pBinds", "const VkSparseMemoryBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseMemoryBind);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageOpaqueMemoryBindInfo(ApiDumpInstance& api_dump, const VkSparseImageOpaqueMemoryBindInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bindCount, "uint32_t", "bindCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBinds, object.bindCount, "const VkSparseMemoryBind*", "pBinds", "const VkSparseMemoryBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseMemoryBind);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageSubresource(ApiDumpInstance& api_dump, const VkImageSubresource& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mipLevel, "uint32_t", "mipLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.arrayLayer, "uint32_t", "arrayLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageMemoryBind(ApiDumpInstance& api_dump, const VkSparseImageMemoryBind& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageSubresource(api_dump, object.subresource, "VkImageSubresource", "subresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.offset, "VkOffset3D", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.extent, "VkExtent3D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSparseMemoryBindFlags(api_dump, object.flags, "VkSparseMemoryBindFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageMemoryBindInfo(ApiDumpInstance& api_dump, const VkSparseImageMemoryBindInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bindCount, "uint32_t", "bindCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBinds, object.bindCount, "const VkSparseImageMemoryBind*", "pBinds", "const VkSparseImageMemoryBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageMemoryBind);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindSparseInfo(ApiDumpInstance& api_dump, const VkBindSparseInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreCount, "uint32_t", "waitSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphores, object.waitSemaphoreCount, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferBindCount, "uint32_t", "bufferBindCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBufferBinds, object.bufferBindCount, "const VkSparseBufferMemoryBindInfo*", "pBufferBinds", "const VkSparseBufferMemoryBindInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseBufferMemoryBindInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageOpaqueBindCount, "uint32_t", "imageOpaqueBindCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImageOpaqueBinds, object.imageOpaqueBindCount, "const VkSparseImageOpaqueMemoryBindInfo*", "pImageOpaqueBinds", "const VkSparseImageOpaqueMemoryBindInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageOpaqueMemoryBindInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageBindCount, "uint32_t", "imageBindCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImageBinds, object.imageBindCount, "const VkSparseImageMemoryBindInfo*", "pImageBinds", "const VkSparseImageMemoryBindInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageMemoryBindInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.signalSemaphoreCount, "uint32_t", "signalSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSignalSemaphores, object.signalSemaphoreCount, "const VkSemaphore*", "pSignalSemaphores", "const VkSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageFormatProperties(ApiDumpInstance& api_dump, const VkSparseImageFormatProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.imageGranularity, "VkExtent3D", "imageGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSparseImageFormatFlags(api_dump, object.flags, "VkSparseImageFormatFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageMemoryRequirements(ApiDumpInstance& api_dump, const VkSparseImageMemoryRequirements& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkSparseImageFormatProperties(api_dump, object.formatProperties, "VkSparseImageFormatProperties", "formatProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageMipTailFirstLod, "uint32_t", "imageMipTailFirstLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.imageMipTailSize, "VkDeviceSize", "imageMipTailSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.imageMipTailOffset, "VkDeviceSize", "imageMipTailOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.imageMipTailStride, "VkDeviceSize", "imageMipTailStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFenceCreateInfo(ApiDumpInstance& api_dump, const VkFenceCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFenceCreateFlags(api_dump, object.flags, "VkFenceCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreCreateInfo(ApiDumpInstance& api_dump, const VkSemaphoreCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphoreCreateFlags(api_dump, object.flags, "VkSemaphoreCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueryPoolCreateInfo(ApiDumpInstance& api_dump, const VkQueryPoolCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryPoolCreateFlags(api_dump, object.flags, "VkQueryPoolCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryType(api_dump, object.queryType, "VkQueryType", "queryType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queryCount, "uint32_t", "queryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryPipelineStatisticFlags(api_dump, object.pipelineStatistics, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCreateInfo(ApiDumpInstance& api_dump, const VkBufferCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCreateFlags(api_dump, object.flags, "VkBufferCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferUsageFlags(api_dump, object.usage, "VkBufferUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSharingMode(api_dump, object.sharingMode, "VkSharingMode", "sharingMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndexCount, "uint32_t", "queueFamilyIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pQueueFamilyIndices, object.queueFamilyIndexCount, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const uint32_t*", "pQueueFamilyIndices", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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 (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageCreateInfo(ApiDumpInstance& api_dump, const VkImageCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCreateFlags(api_dump, object.flags, "VkImageCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageType(api_dump, object.imageType, "VkImageType", "imageType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.extent, "VkExtent3D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mipLevels, "uint32_t", "mipLevels", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.arrayLayers, "uint32_t", "arrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.samples, "VkSampleCountFlagBits", "samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageTiling(api_dump, object.tiling, "VkImageTiling", "tiling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.usage, "VkImageUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSharingMode(api_dump, object.sharingMode, "VkSharingMode", "sharingMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndexCount, "uint32_t", "queueFamilyIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pQueueFamilyIndices, object.queueFamilyIndexCount, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const uint32_t*", "pQueueFamilyIndices", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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_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>);
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.initialLayout, "VkImageLayout", "initialLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubresourceLayout(ApiDumpInstance& api_dump, const VkSubresourceLayout& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.rowPitch, "VkDeviceSize", "rowPitch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.arrayPitch, "VkDeviceSize", "arrayPitch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.depthPitch, "VkDeviceSize", "depthPitch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkComponentMapping(ApiDumpInstance& api_dump, const VkComponentMapping& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkComponentSwizzle(api_dump, object.r, "VkComponentSwizzle", "r", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentSwizzle(api_dump, object.g, "VkComponentSwizzle", "g", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentSwizzle(api_dump, object.b, "VkComponentSwizzle", "b", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentSwizzle(api_dump, object.a, "VkComponentSwizzle", "a", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewCreateInfo(ApiDumpInstance& api_dump, const VkImageViewCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageViewCreateFlags(api_dump, object.flags, "VkImageViewCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageViewType(api_dump, object.viewType, "VkImageViewType", "viewType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.components, "VkComponentMapping", "components", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceRange(api_dump, object.subresourceRange, "VkImageSubresourceRange", "subresourceRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandPoolCreateInfo(ApiDumpInstance& api_dump, const VkCommandPoolCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCommandPoolCreateFlags(api_dump, object.flags, "VkCommandPoolCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndex, "uint32_t", "queueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferAllocateInfo(ApiDumpInstance& api_dump, const VkCommandBufferAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCommandPool(api_dump, object.commandPool, "VkCommandPool", "commandPool", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCommandBufferLevel(api_dump, object.level, "VkCommandBufferLevel", "level", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.commandBufferCount, "uint32_t", "commandBufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferInheritanceInfo(ApiDumpInstance& api_dump, const VkCommandBufferInheritanceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPass(api_dump, object.renderPass, "VkRenderPass", "renderPass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subpass, "uint32_t", "subpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFramebuffer(api_dump, object.framebuffer, "VkFramebuffer", "framebuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.occlusionQueryEnable, "VkBool32", "occlusionQueryEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryControlFlags(api_dump, object.queryFlags, "VkQueryControlFlags", "queryFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryPipelineStatisticFlags(api_dump, object.pipelineStatistics, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferBeginInfo(ApiDumpInstance& api_dump, const VkCommandBufferBeginInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCommandBufferUsageFlags(api_dump, object.flags, "VkCommandBufferUsageFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    if (api_dump.getCmdBufferLevel() == VK_COMMAND_BUFFER_LEVEL_SECONDARY) {
+        dump_pointer(api_dump, object.pInheritanceInfo, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBufferInheritanceInfo);
     } 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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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_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));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCopy(ApiDumpInstance& api_dump, const VkBufferCopy& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkDeviceSize>(api_dump, object.srcOffset, "VkDeviceSize", "srcOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.dstOffset, "VkDeviceSize", "dstOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageSubresourceLayers(ApiDumpInstance& api_dump, const VkImageSubresourceLayers& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mipLevel, "uint32_t", "mipLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseArrayLayer, "uint32_t", "baseArrayLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layerCount, "uint32_t", "layerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferImageCopy(ApiDumpInstance& api_dump, const VkBufferImageCopy& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkDeviceSize>(api_dump, object.bufferOffset, "VkDeviceSize", "bufferOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferRowLength, "uint32_t", "bufferRowLength", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferImageHeight, "uint32_t", "bufferImageHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.imageSubresource, "VkImageSubresourceLayers", "imageSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.imageOffset, "VkOffset3D", "imageOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.imageExtent, "VkExtent3D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageCopy(ApiDumpInstance& api_dump, const VkImageCopy& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageSubresourceLayers(api_dump, object.srcSubresource, "VkImageSubresourceLayers", "srcSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.srcOffset, "VkOffset3D", "srcOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.dstSubresource, "VkImageSubresourceLayers", "dstSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.dstOffset, "VkOffset3D", "dstOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.extent, "VkExtent3D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDispatchIndirectCommand(ApiDumpInstance& api_dump, const VkDispatchIndirectCommand& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.x, "uint32_t", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.y, "uint32_t", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.z, "uint32_t", "z", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCacheHeaderVersionOne(ApiDumpInstance& api_dump, const VkPipelineCacheHeaderVersionOne& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.headerSize, "uint32_t", "headerSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCacheHeaderVersion(api_dump, object.headerVersion, "VkPipelineCacheHeaderVersion", "headerVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vendorID, "uint32_t", "vendorID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceID, "uint32_t", "deviceID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.pipelineCacheUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkEventCreateInfo(ApiDumpInstance& api_dump, const VkEventCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkEventCreateFlags(api_dump, object.flags, "VkEventCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferViewCreateInfo(ApiDumpInstance& api_dump, const VkBufferViewCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferViewCreateFlags(api_dump, object.flags, "VkBufferViewCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.range, "VkDeviceSize", "range", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderModuleCreateInfo(ApiDumpInstance& api_dump, const VkShaderModuleCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderModuleCreateFlags(api_dump, object.flags, "VkShaderModuleCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.codeSize, "size_t", "codeSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+
+    if (api_dump.settings().showShader()) {
+        dump_spirv(api_dump, object.pCode, object.codeSize / 4, "const uint32_t*", "pCode", indents + (api_dump.settings().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);
+        dump_special(api_dump, "SHADER DATA", "const uint32_t*", "pCode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCacheCreateInfo(ApiDumpInstance& api_dump, const VkPipelineCacheCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCacheCreateFlags(api_dump, object.flags, "VkPipelineCacheCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.initialDataSize, "size_t", "initialDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pInitialData, "const void*", "pInitialData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSpecializationMapEntry(ApiDumpInstance& api_dump, const VkSpecializationMapEntry& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.constantID, "uint32_t", "constantID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.size, "size_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSpecializationInfo(ApiDumpInstance& api_dump, const VkSpecializationInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.mapEntryCount, "uint32_t", "mapEntryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pMapEntries, object.mapEntryCount, "const VkSpecializationMapEntry*", "pMapEntries", "const VkSpecializationMapEntry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationMapEntry);
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dataSize, "size_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pData, "const void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineShaderStageCreateInfo(ApiDumpInstance& api_dump, const VkPipelineShaderStageCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineShaderStageCreateFlags(api_dump, object.flags, "VkPipelineShaderStageCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlagBits(api_dump, object.stage, "VkShaderStageFlagBits", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderModule(api_dump, object.module, "VkShaderModule", "module", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pName, "const char*", "pName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSpecializationInfo, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkComputePipelineCreateInfo(ApiDumpInstance& api_dump, const VkComputePipelineCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags(api_dump, object.flags, "VkPipelineCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineShaderStageCreateInfo(api_dump, object.stage, "VkPipelineShaderStageCreateInfo", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.basePipelineHandle, "VkPipeline", "basePipelineHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.basePipelineIndex, "int32_t", "basePipelineIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPushConstantRange(ApiDumpInstance& api_dump, const VkPushConstantRange& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineLayoutCreateInfo(ApiDumpInstance& api_dump, const VkPipelineLayoutCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayoutCreateFlags(api_dump, object.flags, "VkPipelineLayoutCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.setLayoutCount, "uint32_t", "setLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSetLayouts, object.setLayoutCount, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushConstantRangeCount, "uint32_t", "pushConstantRangeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPushConstantRanges, object.pushConstantRangeCount, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerCreateInfo(ApiDumpInstance& api_dump, const VkSamplerCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerCreateFlags(api_dump, object.flags, "VkSamplerCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFilter(api_dump, object.magFilter, "VkFilter", "magFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFilter(api_dump, object.minFilter, "VkFilter", "minFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerMipmapMode(api_dump, object.mipmapMode, "VkSamplerMipmapMode", "mipmapMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerAddressMode(api_dump, object.addressModeU, "VkSamplerAddressMode", "addressModeU", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerAddressMode(api_dump, object.addressModeV, "VkSamplerAddressMode", "addressModeV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerAddressMode(api_dump, object.addressModeW, "VkSamplerAddressMode", "addressModeW", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.mipLodBias, "float", "mipLodBias", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.anisotropyEnable, "VkBool32", "anisotropyEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxAnisotropy, "float", "maxAnisotropy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.compareEnable, "VkBool32", "compareEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompareOp(api_dump, object.compareOp, "VkCompareOp", "compareOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minLod, "float", "minLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxLod, "float", "maxLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBorderColor(api_dump, object.borderColor, "VkBorderColor", "borderColor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.unnormalizedCoordinates, "VkBool32", "unnormalizedCoordinates", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyDescriptorSet(ApiDumpInstance& api_dump, const VkCopyDescriptorSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorSet(api_dump, object.srcSet, "VkDescriptorSet", "srcSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcBinding, "uint32_t", "srcBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcArrayElement, "uint32_t", "srcArrayElement", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorSet(api_dump, object.dstSet, "VkDescriptorSet", "dstSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstBinding, "uint32_t", "dstBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstArrayElement, "uint32_t", "dstArrayElement", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorCount, "uint32_t", "descriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorBufferInfo(ApiDumpInstance& api_dump, const VkDescriptorBufferInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.range, "VkDeviceSize", "range", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorImageInfo(ApiDumpInstance& api_dump, const VkDescriptorImageInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkSampler(api_dump, object.sampler, "VkSampler", "sampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.imageLayout, "VkImageLayout", "imageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorPoolSize(ApiDumpInstance& api_dump, const VkDescriptorPoolSize& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkDescriptorType(api_dump, object.type, "VkDescriptorType", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorCount, "uint32_t", "descriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorPoolCreateInfo(ApiDumpInstance& api_dump, const VkDescriptorPoolCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorPoolCreateFlags(api_dump, object.flags, "VkDescriptorPoolCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSets, "uint32_t", "maxSets", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.poolSizeCount, "uint32_t", "poolSizeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPoolSizes, object.poolSizeCount, "const VkDescriptorPoolSize*", "pPoolSizes", "const VkDescriptorPoolSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorPoolSize);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetAllocateInfo(ApiDumpInstance& api_dump, const VkDescriptorSetAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorPool(api_dump, object.descriptorPool, "VkDescriptorPool", "descriptorPool", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorSetCount, "uint32_t", "descriptorSetCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSetLayouts, object.descriptorSetCount, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetLayoutBinding(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutBinding& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorType(api_dump, object.descriptorType, "VkDescriptorType", "descriptorType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorCount, "uint32_t", "descriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pImmutableSamplers, object.descriptorCount, "const VkSampler*", "pImmutableSamplers", "const VkSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSampler);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkSampler*", "pImmutableSamplers", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetLayoutCreateInfo(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorSetLayoutCreateFlags(api_dump, object.flags, "VkDescriptorSetLayoutCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bindingCount, "uint32_t", "bindingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBindings, object.bindingCount, "const VkDescriptorSetLayoutBinding*", "pBindings", "const VkDescriptorSetLayoutBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayoutBinding);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteDescriptorSet(ApiDumpInstance& api_dump, const VkWriteDescriptorSet& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorSet(api_dump, object.dstSet, "VkDescriptorSet", "dstSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstBinding, "uint32_t", "dstBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstArrayElement, "uint32_t", "dstArrayElement", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorCount, "uint32_t", "descriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorType(api_dump, object.descriptorType, "VkDescriptorType", "descriptorType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pImageInfo, object.descriptorCount, "const VkDescriptorImageInfo*", "pImageInfo", "const VkDescriptorImageInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkDescriptorImageInfo*", "pImageInfo", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "const VkDescriptorImageInfo*", "pImageInfo", indents + 2);
         }
     }
-    dump_separate_members<Format>(settings);
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pBufferInfo, object.descriptorCount, "const VkDescriptorBufferInfo*", "pBufferInfo", "const VkDescriptorBufferInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorBufferInfo);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 2);
         }
     }
-    dump_separate_members<Format>(settings);
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pTexelBufferView, object.descriptorCount, "const VkBufferView*", "pTexelBufferView", "const VkBufferView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferView);
     } 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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkBufferView*", "pTexelBufferView", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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_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_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_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_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_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_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_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>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClearColorValue(ApiDumpInstance& api_dump, const VkClearColorValue& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_single_array(api_dump, object.float32, 4, "float[4]", "float32", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.int32, 4, "int32_t[4]", "int32", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.uint32, 4, "uint32_t[4]", "uint32", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrawIndexedIndirectCommand(ApiDumpInstance& api_dump, const VkDrawIndexedIndirectCommand& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.indexCount, "uint32_t", "indexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCount, "uint32_t", "instanceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstIndex, "uint32_t", "firstIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.vertexOffset, "int32_t", "vertexOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstInstance, "uint32_t", "firstInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrawIndirectCommand(ApiDumpInstance& api_dump, const VkDrawIndirectCommand& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.vertexCount, "uint32_t", "vertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCount, "uint32_t", "instanceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstVertex, "uint32_t", "firstVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstInstance, "uint32_t", "firstInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVertexInputBindingDescription(ApiDumpInstance& api_dump, const VkVertexInputBindingDescription& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stride, "uint32_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVertexInputRate(api_dump, object.inputRate, "VkVertexInputRate", "inputRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVertexInputAttributeDescription(ApiDumpInstance& api_dump, const VkVertexInputAttributeDescription& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.location, "uint32_t", "location", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineVertexInputStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineVertexInputStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineVertexInputStateCreateFlags(api_dump, object.flags, "VkPipelineVertexInputStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexBindingDescriptionCount, "uint32_t", "vertexBindingDescriptionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pVertexBindingDescriptions, object.vertexBindingDescriptionCount, "const VkVertexInputBindingDescription*", "pVertexBindingDescriptions", "const VkVertexInputBindingDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputBindingDescription);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexAttributeDescriptionCount, "uint32_t", "vertexAttributeDescriptionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pVertexAttributeDescriptions, object.vertexAttributeDescriptionCount, "const VkVertexInputAttributeDescription*", "pVertexAttributeDescriptions", "const VkVertexInputAttributeDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputAttributeDescription);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineInputAssemblyStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineInputAssemblyStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineInputAssemblyStateCreateFlags(api_dump, object.flags, "VkPipelineInputAssemblyStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPrimitiveTopology(api_dump, object.topology, "VkPrimitiveTopology", "topology", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveRestartEnable, "VkBool32", "primitiveRestartEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineTessellationStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineTessellationStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineTessellationStateCreateFlags(api_dump, object.flags, "VkPipelineTessellationStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.patchControlPoints, "uint32_t", "patchControlPoints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkViewport(ApiDumpInstance& api_dump, const VkViewport& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.x, "float", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.y, "float", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.width, "float", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.height, "float", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minDepth, "float", "minDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxDepth, "float", "maxDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineViewportStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineViewportStateCreateFlags(api_dump, object.flags, "VkPipelineViewportStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewportCount, "uint32_t", "viewportCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    if (!api_dump.getIsDynamicViewport()) {
+        dump_pointer_array(api_dump, object.pViewports, object.viewportCount, "const VkViewport*", "pViewports", "const VkViewport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkViewport);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkViewport*", "pViewports", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.scissorCount, "uint32_t", "scissorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    if (!api_dump.getIsDynamicScissor()) {
+        dump_pointer_array(api_dump, object.pScissors, object.scissorCount, "const VkRect2D*", "pScissors", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
     } 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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkRect2D*", "pScissors", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineRasterizationStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRasterizationStateCreateFlags(api_dump, object.flags, "VkPipelineRasterizationStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClampEnable, "VkBool32", "depthClampEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rasterizerDiscardEnable, "VkBool32", "rasterizerDiscardEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPolygonMode(api_dump, object.polygonMode, "VkPolygonMode", "polygonMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCullModeFlags(api_dump, object.cullMode, "VkCullModeFlags", "cullMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFrontFace(api_dump, object.frontFace, "VkFrontFace", "frontFace", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBiasEnable, "VkBool32", "depthBiasEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.depthBiasConstantFactor, "float", "depthBiasConstantFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.depthBiasClamp, "float", "depthBiasClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.depthBiasSlopeFactor, "float", "depthBiasSlopeFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.lineWidth, "float", "lineWidth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineMultisampleStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineMultisampleStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineMultisampleStateCreateFlags(api_dump, object.flags, "VkPipelineMultisampleStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.rasterizationSamples, "VkSampleCountFlagBits", "rasterizationSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sampleShadingEnable, "VkBool32", "sampleShadingEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minSampleShading, "float", "minSampleShading", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSampleMask, (object.rasterizationSamples + 31) / 32, "const VkSampleMask*", "pSampleMask", "const VkSampleMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const VkSampleMask>);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.alphaToCoverageEnable, "VkBool32", "alphaToCoverageEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.alphaToOneEnable, "VkBool32", "alphaToOneEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkStencilOpState(ApiDumpInstance& api_dump, const VkStencilOpState& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStencilOp(api_dump, object.failOp, "VkStencilOp", "failOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStencilOp(api_dump, object.passOp, "VkStencilOp", "passOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStencilOp(api_dump, object.depthFailOp, "VkStencilOp", "depthFailOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompareOp(api_dump, object.compareOp, "VkCompareOp", "compareOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.compareMask, "uint32_t", "compareMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.writeMask, "uint32_t", "writeMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reference, "uint32_t", "reference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineDepthStencilStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineDepthStencilStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineDepthStencilStateCreateFlags(api_dump, object.flags, "VkPipelineDepthStencilStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthTestEnable, "VkBool32", "depthTestEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthWriteEnable, "VkBool32", "depthWriteEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompareOp(api_dump, object.depthCompareOp, "VkCompareOp", "depthCompareOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBoundsTestEnable, "VkBool32", "depthBoundsTestEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stencilTestEnable, "VkBool32", "stencilTestEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStencilOpState(api_dump, object.front, "VkStencilOpState", "front", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStencilOpState(api_dump, object.back, "VkStencilOpState", "back", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minDepthBounds, "float", "minDepthBounds", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxDepthBounds, "float", "maxDepthBounds", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineColorBlendAttachmentState(ApiDumpInstance& api_dump, const VkPipelineColorBlendAttachmentState& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<VkBool32>(api_dump, object.blendEnable, "VkBool32", "blendEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.srcColorBlendFactor, "VkBlendFactor", "srcColorBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.dstColorBlendFactor, "VkBlendFactor", "dstColorBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendOp(api_dump, object.colorBlendOp, "VkBlendOp", "colorBlendOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.srcAlphaBlendFactor, "VkBlendFactor", "srcAlphaBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.dstAlphaBlendFactor, "VkBlendFactor", "dstAlphaBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendOp(api_dump, object.alphaBlendOp, "VkBlendOp", "alphaBlendOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkColorComponentFlags(api_dump, object.colorWriteMask, "VkColorComponentFlags", "colorWriteMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineColorBlendStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineColorBlendStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineColorBlendStateCreateFlags(api_dump, object.flags, "VkPipelineColorBlendStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.logicOpEnable, "VkBool32", "logicOpEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkLogicOp(api_dump, object.logicOp, "VkLogicOp", "logicOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentCount, "uint32_t", "attachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachments, object.attachmentCount, "const VkPipelineColorBlendAttachmentState*", "pAttachments", "const VkPipelineColorBlendAttachmentState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineColorBlendAttachmentState);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.blendConstants, 4, "float[4]", "blendConstants", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineDynamicStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineDynamicStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineDynamicStateCreateFlags(api_dump, object.flags, "VkPipelineDynamicStateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dynamicStateCount, "uint32_t", "dynamicStateCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDynamicStates, object.dynamicStateCount, "const VkDynamicState*", "pDynamicStates", "const VkDynamicState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDynamicState);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGraphicsPipelineCreateInfo(ApiDumpInstance& api_dump, const VkGraphicsPipelineCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setIsDynamicViewport(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_VIEWPORT) > 0);
+    api_dump.setIsDynamicScissor(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_SCISSOR));
+    api_dump.setIsGPLPreRasterOrFragmentShader(checkForGPLPreRasterOrFragmentShader(object));
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags(api_dump, object.flags, "VkPipelineCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stageCount, "uint32_t", "stageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStages, object.stageCount, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pVertexInputState, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineVertexInputStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pInputAssemblyState, "const VkPipelineInputAssemblyStateCreateInfo*", "pInputAssemblyState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineInputAssemblyStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTessellationState, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineTessellationStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pViewportState, "const VkPipelineViewportStateCreateInfo*", "pViewportState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineViewportStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pRasterizationState, "const VkPipelineRasterizationStateCreateInfo*", "pRasterizationState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineRasterizationStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pMultisampleState, "const VkPipelineMultisampleStateCreateInfo*", "pMultisampleState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineMultisampleStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthStencilState, "const VkPipelineDepthStencilStateCreateInfo*", "pDepthStencilState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDepthStencilStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pColorBlendState, "const VkPipelineColorBlendStateCreateInfo*", "pColorBlendState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineColorBlendStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDynamicState, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDynamicStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPass(api_dump, object.renderPass, "VkRenderPass", "renderPass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subpass, "uint32_t", "subpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.basePipelineHandle, "VkPipeline", "basePipelineHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.basePipelineIndex, "int32_t", "basePipelineIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentDescription(ApiDumpInstance& api_dump, const VkAttachmentDescription& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkAttachmentDescriptionFlags(api_dump, object.flags, "VkAttachmentDescriptionFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.samples, "VkSampleCountFlagBits", "samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentLoadOp(api_dump, object.loadOp, "VkAttachmentLoadOp", "loadOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentStoreOp(api_dump, object.storeOp, "VkAttachmentStoreOp", "storeOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentLoadOp(api_dump, object.stencilLoadOp, "VkAttachmentLoadOp", "stencilLoadOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentStoreOp(api_dump, object.stencilStoreOp, "VkAttachmentStoreOp", "stencilStoreOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.initialLayout, "VkImageLayout", "initialLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.finalLayout, "VkImageLayout", "finalLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentReference(ApiDumpInstance& api_dump, const VkAttachmentReference& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.attachment, "uint32_t", "attachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.layout, "VkImageLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFramebufferCreateInfo(ApiDumpInstance& api_dump, const VkFramebufferCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFramebufferCreateFlags(api_dump, object.flags, "VkFramebufferCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPass(api_dump, object.renderPass, "VkRenderPass", "renderPass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentCount, "uint32_t", "attachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachments, object.attachmentCount, "const VkImageView*", "pAttachments", "const VkImageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageView);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layers, "uint32_t", "layers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassDescription(ApiDumpInstance& api_dump, const VkSubpassDescription& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkSubpassDescriptionFlags(api_dump, object.flags, "VkSubpassDescriptionFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.inputAttachmentCount, "uint32_t", "inputAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pInputAttachments, object.inputAttachmentCount, "const VkAttachmentReference*", "pInputAttachments", "const VkAttachmentReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachments, object.colorAttachmentCount, "const VkAttachmentReference*", "pColorAttachments", "const VkAttachmentReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pResolveAttachments, object.colorAttachmentCount, "const VkAttachmentReference*", "pResolveAttachments", "const VkAttachmentReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthStencilAttachment, "const VkAttachmentReference*", "pDepthStencilAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preserveAttachmentCount, "uint32_t", "preserveAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPreserveAttachments, object.preserveAttachmentCount, "const uint32_t*", "pPreserveAttachments", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassDependency(ApiDumpInstance& api_dump, const VkSubpassDependency& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.srcSubpass, "uint32_t", "srcSubpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstSubpass, "uint32_t", "dstSubpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags(api_dump, object.srcStageMask, "VkPipelineStageFlags", "srcStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags(api_dump, object.dstStageMask, "VkPipelineStageFlags", "dstStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.srcAccessMask, "VkAccessFlags", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.dstAccessMask, "VkAccessFlags", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDependencyFlags(api_dump, object.dependencyFlags, "VkDependencyFlags", "dependencyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassCreateInfo(ApiDumpInstance& api_dump, const VkRenderPassCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPassCreateFlags(api_dump, object.flags, "VkRenderPassCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentCount, "uint32_t", "attachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachments, object.attachmentCount, "const VkAttachmentDescription*", "pAttachments", "const VkAttachmentDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentDescription);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subpassCount, "uint32_t", "subpassCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSubpasses, object.subpassCount, "const VkSubpassDescription*", "pSubpasses", "const VkSubpassDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDescription);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dependencyCount, "uint32_t", "dependencyCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDependencies, object.dependencyCount, "const VkSubpassDependency*", "pDependencies", "const VkSubpassDependency", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDependency);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClearDepthStencilValue(ApiDumpInstance& api_dump, const VkClearDepthStencilValue& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.depth, "float", "depth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stencil, "uint32_t", "stencil", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClearValue(ApiDumpInstance& api_dump, const VkClearValue& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_VkClearColorValue(api_dump, object.color, "VkClearColorValue", "color", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClearDepthStencilValue(api_dump, object.depthStencil, "VkClearDepthStencilValue", "depthStencil", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClearAttachment(ApiDumpInstance& api_dump, const VkClearAttachment& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachment, "uint32_t", "colorAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClearValue(api_dump, object.clearValue, "VkClearValue", "clearValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClearRect(ApiDumpInstance& api_dump, const VkClearRect& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkRect2D(api_dump, object.rect, "VkRect2D", "rect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseArrayLayer, "uint32_t", "baseArrayLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layerCount, "uint32_t", "layerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageBlit(ApiDumpInstance& api_dump, const VkImageBlit& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageSubresourceLayers(api_dump, object.srcSubresource, "VkImageSubresourceLayers", "srcSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.srcOffsets, 2, "VkOffset3D[2]", "srcOffsets", "VkOffset3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D);
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.dstSubresource, "VkImageSubresourceLayers", "dstSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.dstOffsets, 2, "VkOffset3D[2]", "dstOffsets", "VkOffset3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageResolve(ApiDumpInstance& api_dump, const VkImageResolve& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageSubresourceLayers(api_dump, object.srcSubresource, "VkImageSubresourceLayers", "srcSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.srcOffset, "VkOffset3D", "srcOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.dstSubresource, "VkImageSubresourceLayers", "dstSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.dstOffset, "VkOffset3D", "dstOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.extent, "VkExtent3D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassBeginInfo(ApiDumpInstance& api_dump, const VkRenderPassBeginInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPass(api_dump, object.renderPass, "VkRenderPass", "renderPass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFramebuffer(api_dump, object.framebuffer, "VkFramebuffer", "framebuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRect2D(api_dump, object.renderArea, "VkRect2D", "renderArea", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clearValueCount, "uint32_t", "clearValueCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pClearValues, object.clearValueCount, "const VkClearValue*", "pClearValues", "const VkClearValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkClearValue);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindBufferMemoryInfo(ApiDumpInstance& api_dump, const VkBindBufferMemoryInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindImageMemoryInfo(ApiDumpInstance& api_dump, const VkBindImageMemoryInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryDedicatedRequirements(ApiDumpInstance& api_dump, const VkMemoryDedicatedRequirements& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersDedicatedAllocation, "VkBool32", "prefersDedicatedAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.requiresDedicatedAllocation, "VkBool32", "requiresDedicatedAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryDedicatedAllocateInfo(ApiDumpInstance& api_dump, const VkMemoryDedicatedAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryAllocateFlagsInfo(ApiDumpInstance& api_dump, const VkMemoryAllocateFlagsInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryAllocateFlags(api_dump, object.flags, "VkMemoryAllocateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceMask, "uint32_t", "deviceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupCommandBufferBeginInfo(ApiDumpInstance& api_dump, const VkDeviceGroupCommandBufferBeginInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceMask, "uint32_t", "deviceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupSubmitInfo(ApiDumpInstance& api_dump, const VkDeviceGroupSubmitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreCount, "uint32_t", "waitSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphoreDeviceIndices, object.waitSemaphoreCount, "const uint32_t*", "pWaitSemaphoreDeviceIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.commandBufferCount, "uint32_t", "commandBufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCommandBufferDeviceMasks, object.commandBufferCount, "const uint32_t*", "pCommandBufferDeviceMasks", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.signalSemaphoreCount, "uint32_t", "signalSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSignalSemaphoreDeviceIndices, object.signalSemaphoreCount, "const uint32_t*", "pSignalSemaphoreDeviceIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupBindSparseInfo(ApiDumpInstance& api_dump, const VkDeviceGroupBindSparseInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.resourceDeviceIndex, "uint32_t", "resourceDeviceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryDeviceIndex, "uint32_t", "memoryDeviceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindBufferMemoryDeviceGroupInfo(ApiDumpInstance& api_dump, const VkBindBufferMemoryDeviceGroupInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceIndexCount, "uint32_t", "deviceIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDeviceIndices, object.deviceIndexCount, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindImageMemoryDeviceGroupInfo(ApiDumpInstance& api_dump, const VkBindImageMemoryDeviceGroupInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceIndexCount, "uint32_t", "deviceIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDeviceIndices, object.deviceIndexCount, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.splitInstanceBindRegionCount, "uint32_t", "splitInstanceBindRegionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSplitInstanceBindRegions, object.splitInstanceBindRegionCount, "const VkRect2D*", "pSplitInstanceBindRegions", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceGroupProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceGroupProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.physicalDeviceCount, "uint32_t", "physicalDeviceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.physicalDevices, std::min(object.physicalDeviceCount, VK_MAX_DEVICE_GROUP_SIZE), "VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]", "physicalDevices", "VkPhysicalDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDevice);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subsetAllocation, "VkBool32", "subsetAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupDeviceCreateInfo(ApiDumpInstance& api_dump, const VkDeviceGroupDeviceCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.physicalDeviceCount, "uint32_t", "physicalDeviceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPhysicalDevices, object.physicalDeviceCount, "const VkPhysicalDevice*", "pPhysicalDevices", "const VkPhysicalDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDevice);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferMemoryRequirementsInfo2(ApiDumpInstance& api_dump, const VkBufferMemoryRequirementsInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageMemoryRequirementsInfo2(ApiDumpInstance& api_dump, const VkImageMemoryRequirementsInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageSparseMemoryRequirementsInfo2(ApiDumpInstance& api_dump, const VkImageSparseMemoryRequirementsInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryRequirements2(ApiDumpInstance& api_dump, const VkMemoryRequirements2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryRequirements(api_dump, object.memoryRequirements, "VkMemoryRequirements", "memoryRequirements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageMemoryRequirements2(ApiDumpInstance& api_dump, const VkSparseImageMemoryRequirements2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSparseImageMemoryRequirements(api_dump, object.memoryRequirements, "VkSparseImageMemoryRequirements", "memoryRequirements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFeatures2(ApiDumpInstance& api_dump, const VkPhysicalDeviceFeatures2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceFeatures(api_dump, object.features, "VkPhysicalDeviceFeatures", "features", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceProperties2(ApiDumpInstance& api_dump, const VkPhysicalDeviceProperties2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceProperties(api_dump, object.properties, "VkPhysicalDeviceProperties", "properties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFormatProperties2(ApiDumpInstance& api_dump, const VkFormatProperties2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatProperties(api_dump, object.formatProperties, "VkFormatProperties", "formatProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageFormatProperties2(ApiDumpInstance& api_dump, const VkImageFormatProperties2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageFormatProperties(api_dump, object.imageFormatProperties, "VkImageFormatProperties", "imageFormatProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageFormatInfo2(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageFormatInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageType(api_dump, object.type, "VkImageType", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageTiling(api_dump, object.tiling, "VkImageTiling", "tiling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.usage, "VkImageUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCreateFlags(api_dump, object.flags, "VkImageCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyProperties2(ApiDumpInstance& api_dump, const VkQueueFamilyProperties2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueueFamilyProperties(api_dump, object.queueFamilyProperties, "VkQueueFamilyProperties", "queueFamilyProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMemoryProperties2(ApiDumpInstance& api_dump, const VkPhysicalDeviceMemoryProperties2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setMemoryHeapCount(object.memoryProperties.memoryHeapCount);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceMemoryProperties(api_dump, object.memoryProperties, "VkPhysicalDeviceMemoryProperties", "memoryProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSparseImageFormatProperties2(ApiDumpInstance& api_dump, const VkSparseImageFormatProperties2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSparseImageFormatProperties(api_dump, object.properties, "VkSparseImageFormatProperties", "properties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSparseImageFormatInfo2(ApiDumpInstance& api_dump, const VkPhysicalDeviceSparseImageFormatInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageType(api_dump, object.type, "VkImageType", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.samples, "VkSampleCountFlagBits", "samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.usage, "VkImageUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageTiling(api_dump, object.tiling, "VkImageTiling", "tiling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewUsageCreateInfo(ApiDumpInstance& api_dump, const VkImageViewUsageCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.usage, "VkImageUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceProtectedMemoryFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceProtectedMemoryFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.protectedMemory, "VkBool32", "protectedMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceProtectedMemoryProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceProtectedMemoryProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.protectedNoFault, "VkBool32", "protectedNoFault", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceQueueInfo2(ApiDumpInstance& api_dump, const VkDeviceQueueInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceQueueCreateFlags(api_dump, object.flags, "VkDeviceQueueCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndex, "uint32_t", "queueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueIndex, "uint32_t", "queueIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkProtectedSubmitInfo(ApiDumpInstance& api_dump, const VkProtectedSubmitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.protectedSubmit, "VkBool32", "protectedSubmit", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindImagePlaneMemoryInfo(ApiDumpInstance& api_dump, const VkBindImagePlaneMemoryInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlagBits(api_dump, object.planeAspect, "VkImageAspectFlagBits", "planeAspect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImagePlaneMemoryRequirementsInfo(ApiDumpInstance& api_dump, const VkImagePlaneMemoryRequirementsInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlagBits(api_dump, object.planeAspect, "VkImageAspectFlagBits", "planeAspect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalMemoryProperties(ApiDumpInstance& api_dump, const VkExternalMemoryProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkExternalMemoryFeatureFlags(api_dump, object.externalMemoryFeatures, "VkExternalMemoryFeatureFlags", "externalMemoryFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.exportFromImportedHandleTypes, "VkExternalMemoryHandleTypeFlags", "exportFromImportedHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.compatibleHandleTypes, "VkExternalMemoryHandleTypeFlags", "compatibleHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalImageFormatInfo(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalImageFormatInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalImageFormatProperties(ApiDumpInstance& api_dump, const VkExternalImageFormatProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryProperties(api_dump, object.externalMemoryProperties, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalBufferInfo(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalBufferInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCreateFlags(api_dump, object.flags, "VkBufferCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferUsageFlags(api_dump, object.usage, "VkBufferUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalBufferProperties(ApiDumpInstance& api_dump, const VkExternalBufferProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryProperties(api_dump, object.externalMemoryProperties, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceIDProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceIDProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.deviceUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "deviceUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.driverUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "driverUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.deviceLUID, VK_LUID_SIZE, "uint8_t[VK_LUID_SIZE]", "deviceLUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceNodeMask, "uint32_t", "deviceNodeMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceLUIDValid, "VkBool32", "deviceLUIDValid", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalMemoryImageCreateInfo(ApiDumpInstance& api_dump, const VkExternalMemoryImageCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.handleTypes, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalMemoryBufferCreateInfo(ApiDumpInstance& api_dump, const VkExternalMemoryBufferCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.handleTypes, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMemoryAllocateInfo(ApiDumpInstance& api_dump, const VkExportMemoryAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.handleTypes, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalFenceInfo(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalFenceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlagBits(api_dump, object.handleType, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalFenceProperties(ApiDumpInstance& api_dump, const VkExternalFenceProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlags(api_dump, object.exportFromImportedHandleTypes, "VkExternalFenceHandleTypeFlags", "exportFromImportedHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlags(api_dump, object.compatibleHandleTypes, "VkExternalFenceHandleTypeFlags", "compatibleHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceFeatureFlags(api_dump, object.externalFenceFeatures, "VkExternalFenceFeatureFlags", "externalFenceFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportFenceCreateInfo(ApiDumpInstance& api_dump, const VkExportFenceCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlags(api_dump, object.handleTypes, "VkExternalFenceHandleTypeFlags", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportSemaphoreCreateInfo(ApiDumpInstance& api_dump, const VkExportSemaphoreCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlags(api_dump, object.handleTypes, "VkExternalSemaphoreHandleTypeFlags", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalSemaphoreInfo(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalSemaphoreInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalSemaphoreProperties(ApiDumpInstance& api_dump, const VkExternalSemaphoreProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlags(api_dump, object.exportFromImportedHandleTypes, "VkExternalSemaphoreHandleTypeFlags", "exportFromImportedHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlags(api_dump, object.compatibleHandleTypes, "VkExternalSemaphoreHandleTypeFlags", "compatibleHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreFeatureFlags(api_dump, object.externalSemaphoreFeatures, "VkExternalSemaphoreFeatureFlags", "externalSemaphoreFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSubgroupProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceSubgroupProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subgroupSize, "uint32_t", "subgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.supportedStages, "VkShaderStageFlags", "supportedStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSubgroupFeatureFlags(api_dump, object.supportedOperations, "VkSubgroupFeatureFlags", "supportedOperations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.quadOperationsInAllStages, "VkBool32", "quadOperationsInAllStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevice16BitStorageFeatures(ApiDumpInstance& api_dump, const VkPhysicalDevice16BitStorageFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageBuffer16BitAccess, "VkBool32", "storageBuffer16BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformAndStorageBuffer16BitAccess, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storagePushConstant16, "VkBool32", "storagePushConstant16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageInputOutput16, "VkBool32", "storageInputOutput16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVariablePointersFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceVariablePointersFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.variablePointersStorageBuffer, "VkBool32", "variablePointersStorageBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.variablePointers, "VkBool32", "variablePointers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorUpdateTemplateEntry(ApiDumpInstance& api_dump, const VkDescriptorUpdateTemplateEntry& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.dstBinding, "uint32_t", "dstBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstArrayElement, "uint32_t", "dstArrayElement", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorCount, "uint32_t", "descriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorType(api_dump, object.descriptorType, "VkDescriptorType", "descriptorType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.offset, "size_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.stride, "size_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorUpdateTemplateCreateInfo(ApiDumpInstance& api_dump, const VkDescriptorUpdateTemplateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorUpdateTemplateCreateFlags(api_dump, object.flags, "VkDescriptorUpdateTemplateCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorUpdateEntryCount, "uint32_t", "descriptorUpdateEntryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDescriptorUpdateEntries, object.descriptorUpdateEntryCount, "const VkDescriptorUpdateTemplateEntry*", "pDescriptorUpdateEntries", "const VkDescriptorUpdateTemplateEntry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorUpdateTemplateEntry);
+    dump_separate_members(api_dump);
+    dump_VkDescriptorUpdateTemplateType(api_dump, object.templateType, "VkDescriptorUpdateTemplateType", "templateType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorSetLayout(api_dump, object.descriptorSetLayout, "VkDescriptorSetLayout", "descriptorSetLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.pipelineLayout, "VkPipelineLayout", "pipelineLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.set, "uint32_t", "set", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance3Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance3Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerSetDescriptors, "uint32_t", "maxPerSetDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxMemoryAllocationSize, "VkDeviceSize", "maxMemoryAllocationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetLayoutSupport(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutSupport& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.supported, "VkBool32", "supported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerYcbcrConversionCreateInfo(ApiDumpInstance& api_dump, const VkSamplerYcbcrConversionCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrModelConversion(api_dump, object.ycbcrModel, "VkSamplerYcbcrModelConversion", "ycbcrModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrRange(api_dump, object.ycbcrRange, "VkSamplerYcbcrRange", "ycbcrRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.components, "VkComponentMapping", "components", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.xChromaOffset, "VkChromaLocation", "xChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.yChromaOffset, "VkChromaLocation", "yChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFilter(api_dump, object.chromaFilter, "VkFilter", "chromaFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.forceExplicitReconstruction, "VkBool32", "forceExplicitReconstruction", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerYcbcrConversionInfo(ApiDumpInstance& api_dump, const VkSamplerYcbcrConversionInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrConversion(api_dump, object.conversion, "VkSamplerYcbcrConversion", "conversion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSamplerYcbcrConversionFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceSamplerYcbcrConversionFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.samplerYcbcrConversion, "VkBool32", "samplerYcbcrConversion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerYcbcrConversionImageFormatProperties(ApiDumpInstance& api_dump, const VkSamplerYcbcrConversionImageFormatProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.combinedImageSamplerDescriptorCount, "uint32_t", "combinedImageSamplerDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupRenderPassBeginInfo(ApiDumpInstance& api_dump, const VkDeviceGroupRenderPassBeginInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceMask, "uint32_t", "deviceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceRenderAreaCount, "uint32_t", "deviceRenderAreaCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDeviceRenderAreas, object.deviceRenderAreaCount, "const VkRect2D*", "pDeviceRenderAreas", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePointClippingProperties(ApiDumpInstance& api_dump, const VkPhysicalDevicePointClippingProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPointClippingBehavior(api_dump, object.pointClippingBehavior, "VkPointClippingBehavior", "pointClippingBehavior", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkInputAttachmentAspectReference(ApiDumpInstance& api_dump, const VkInputAttachmentAspectReference& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.subpass, "uint32_t", "subpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.inputAttachmentIndex, "uint32_t", "inputAttachmentIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassInputAttachmentAspectCreateInfo(ApiDumpInstance& api_dump, const VkRenderPassInputAttachmentAspectCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.aspectReferenceCount, "uint32_t", "aspectReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAspectReferences, object.aspectReferenceCount, "const VkInputAttachmentAspectReference*", "pAspectReferences", "const VkInputAttachmentAspectReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkInputAttachmentAspectReference);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineTessellationDomainOriginStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineTessellationDomainOriginStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTessellationDomainOrigin(api_dump, object.domainOrigin, "VkTessellationDomainOrigin", "domainOrigin", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassMultiviewCreateInfo(ApiDumpInstance& api_dump, const VkRenderPassMultiviewCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subpassCount, "uint32_t", "subpassCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pViewMasks, object.subpassCount, "const uint32_t*", "pViewMasks", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dependencyCount, "uint32_t", "dependencyCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pViewOffsets, object.dependencyCount, "const int32_t*", "pViewOffsets", "const int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.correlationMaskCount, "uint32_t", "correlationMaskCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCorrelationMasks, object.correlationMaskCount, "const uint32_t*", "pCorrelationMasks", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiviewFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiviewFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiview, "VkBool32", "multiview", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewGeometryShader, "VkBool32", "multiviewGeometryShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewTessellationShader, "VkBool32", "multiviewTessellationShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiviewProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiviewProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMultiviewViewCount, "uint32_t", "maxMultiviewViewCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMultiviewInstanceIndex, "uint32_t", "maxMultiviewInstanceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderDrawParametersFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderDrawParametersFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDrawParameters, "VkBool32", "shaderDrawParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan11Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan11Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageBuffer16BitAccess, "VkBool32", "storageBuffer16BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformAndStorageBuffer16BitAccess, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storagePushConstant16, "VkBool32", "storagePushConstant16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageInputOutput16, "VkBool32", "storageInputOutput16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiview, "VkBool32", "multiview", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewGeometryShader, "VkBool32", "multiviewGeometryShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewTessellationShader, "VkBool32", "multiviewTessellationShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.variablePointersStorageBuffer, "VkBool32", "variablePointersStorageBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.variablePointers, "VkBool32", "variablePointers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.protectedMemory, "VkBool32", "protectedMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.samplerYcbcrConversion, "VkBool32", "samplerYcbcrConversion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDrawParameters, "VkBool32", "shaderDrawParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan11Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan11Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.deviceUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "deviceUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.driverUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "driverUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.deviceLUID, VK_LUID_SIZE, "uint8_t[VK_LUID_SIZE]", "deviceLUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceNodeMask, "uint32_t", "deviceNodeMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceLUIDValid, "VkBool32", "deviceLUIDValid", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subgroupSize, "uint32_t", "subgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.subgroupSupportedStages, "VkShaderStageFlags", "subgroupSupportedStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSubgroupFeatureFlags(api_dump, object.subgroupSupportedOperations, "VkSubgroupFeatureFlags", "subgroupSupportedOperations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subgroupQuadOperationsInAllStages, "VkBool32", "subgroupQuadOperationsInAllStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPointClippingBehavior(api_dump, object.pointClippingBehavior, "VkPointClippingBehavior", "pointClippingBehavior", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMultiviewViewCount, "uint32_t", "maxMultiviewViewCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMultiviewInstanceIndex, "uint32_t", "maxMultiviewInstanceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.protectedNoFault, "VkBool32", "protectedNoFault", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerSetDescriptors, "uint32_t", "maxPerSetDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxMemoryAllocationSize, "VkDeviceSize", "maxMemoryAllocationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan12Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan12Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.samplerMirrorClampToEdge, "VkBool32", "samplerMirrorClampToEdge", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.drawIndirectCount, "VkBool32", "drawIndirectCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageBuffer8BitAccess, "VkBool32", "storageBuffer8BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformAndStorageBuffer8BitAccess, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storagePushConstant8, "VkBool32", "storagePushConstant8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferInt64Atomics, "VkBool32", "shaderBufferInt64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedInt64Atomics, "VkBool32", "shaderSharedInt64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloat16, "VkBool32", "shaderFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInt8, "VkBool32", "shaderInt8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorIndexing, "VkBool32", "descriptorIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInputAttachmentArrayDynamicIndexing, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformTexelBufferArrayDynamicIndexing, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTexelBufferArrayDynamicIndexing, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformBufferArrayNonUniformIndexing, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSampledImageArrayNonUniformIndexing, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageBufferArrayNonUniformIndexing, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageArrayNonUniformIndexing, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInputAttachmentArrayNonUniformIndexing, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformTexelBufferArrayNonUniformIndexing, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTexelBufferArrayNonUniformIndexing, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingUniformBufferUpdateAfterBind, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingSampledImageUpdateAfterBind, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageImageUpdateAfterBind, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageBufferUpdateAfterBind, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingUniformTexelBufferUpdateAfterBind, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageTexelBufferUpdateAfterBind, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingUpdateUnusedWhilePending, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingPartiallyBound, "VkBool32", "descriptorBindingPartiallyBound", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingVariableDescriptorCount, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.runtimeDescriptorArray, "VkBool32", "runtimeDescriptorArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.samplerFilterMinmax, "VkBool32", "samplerFilterMinmax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.scalarBlockLayout, "VkBool32", "scalarBlockLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imagelessFramebuffer, "VkBool32", "imagelessFramebuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformBufferStandardLayout, "VkBool32", "uniformBufferStandardLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupExtendedTypes, "VkBool32", "shaderSubgroupExtendedTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.separateDepthStencilLayouts, "VkBool32", "separateDepthStencilLayouts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hostQueryReset, "VkBool32", "hostQueryReset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.timelineSemaphore, "VkBool32", "timelineSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddress, "VkBool32", "bufferDeviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddressCaptureReplay, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddressMultiDevice, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vulkanMemoryModel, "VkBool32", "vulkanMemoryModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vulkanMemoryModelDeviceScope, "VkBool32", "vulkanMemoryModelDeviceScope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vulkanMemoryModelAvailabilityVisibilityChains, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderOutputViewportIndex, "VkBool32", "shaderOutputViewportIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderOutputLayer, "VkBool32", "shaderOutputLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subgroupBroadcastDynamicId, "VkBool32", "subgroupBroadcastDynamicId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkConformanceVersion(ApiDumpInstance& api_dump, const VkConformanceVersion& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.major, "uint8_t", "major", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minor, "uint8_t", "minor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subminor, "uint8_t", "subminor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.patch, "uint8_t", "patch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan12Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan12Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDriverId(api_dump, object.driverID, "VkDriverId", "driverID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.driverName, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.driverInfo, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkConformanceVersion(api_dump, object.conformanceVersion, "VkConformanceVersion", "conformanceVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderFloatControlsIndependence(api_dump, object.denormBehaviorIndependence, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderFloatControlsIndependence(api_dump, object.roundingModeIndependence, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSignedZeroInfNanPreserveFloat16, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSignedZeroInfNanPreserveFloat32, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSignedZeroInfNanPreserveFloat64, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormPreserveFloat16, "VkBool32", "shaderDenormPreserveFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormPreserveFloat32, "VkBool32", "shaderDenormPreserveFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormPreserveFloat64, "VkBool32", "shaderDenormPreserveFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormFlushToZeroFloat16, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormFlushToZeroFloat32, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormFlushToZeroFloat64, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTEFloat16, "VkBool32", "shaderRoundingModeRTEFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTEFloat32, "VkBool32", "shaderRoundingModeRTEFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTEFloat64, "VkBool32", "shaderRoundingModeRTEFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTZFloat16, "VkBool32", "shaderRoundingModeRTZFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTZFloat32, "VkBool32", "shaderRoundingModeRTZFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTZFloat64, "VkBool32", "shaderRoundingModeRTZFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxUpdateAfterBindDescriptorsInAllPools, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformBufferArrayNonUniformIndexingNative, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSampledImageArrayNonUniformIndexingNative, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageBufferArrayNonUniformIndexingNative, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageArrayNonUniformIndexingNative, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInputAttachmentArrayNonUniformIndexingNative, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustBufferAccessUpdateAfterBind, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.quadDivergentImplicitLod, "VkBool32", "quadDivergentImplicitLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindSamplers, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindSampledImages, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindStorageImages, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindInputAttachments, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageUpdateAfterBindResources, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindSamplers, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindUniformBuffers, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageBuffers, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindSampledImages, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageImages, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindInputAttachments, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlags(api_dump, object.supportedDepthResolveModes, "VkResolveModeFlags", "supportedDepthResolveModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlags(api_dump, object.supportedStencilResolveModes, "VkResolveModeFlags", "supportedStencilResolveModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.independentResolveNone, "VkBool32", "independentResolveNone", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.independentResolve, "VkBool32", "independentResolve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filterMinmaxSingleComponentFormats, "VkBool32", "filterMinmaxSingleComponentFormats", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filterMinmaxImageComponentMapping, "VkBool32", "filterMinmaxImageComponentMapping", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxTimelineSemaphoreValueDifference, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.framebufferIntegerColorSampleCounts, "VkSampleCountFlags", "framebufferIntegerColorSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageFormatListCreateInfo(ApiDumpInstance& api_dump, const VkImageFormatListCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewFormatCount, "uint32_t", "viewFormatCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pViewFormats, object.viewFormatCount, "const VkFormat*", "pViewFormats", "const VkFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDriverProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceDriverProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDriverId(api_dump, object.driverID, "VkDriverId", "driverID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.driverName, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.driverInfo, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkConformanceVersion(api_dump, object.conformanceVersion, "VkConformanceVersion", "conformanceVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkanMemoryModelFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkanMemoryModelFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vulkanMemoryModel, "VkBool32", "vulkanMemoryModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vulkanMemoryModelDeviceScope, "VkBool32", "vulkanMemoryModelDeviceScope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vulkanMemoryModelAvailabilityVisibilityChains, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceHostQueryResetFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceHostQueryResetFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hostQueryReset, "VkBool32", "hostQueryReset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTimelineSemaphoreFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceTimelineSemaphoreFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.timelineSemaphore, "VkBool32", "timelineSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTimelineSemaphoreProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceTimelineSemaphoreProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxTimelineSemaphoreValueDifference, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreTypeCreateInfo(ApiDumpInstance& api_dump, const VkSemaphoreTypeCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphoreType(api_dump, object.semaphoreType, "VkSemaphoreType", "semaphoreType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.initialValue, "uint64_t", "initialValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTimelineSemaphoreSubmitInfo(ApiDumpInstance& api_dump, const VkTimelineSemaphoreSubmitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreValueCount, "uint32_t", "waitSemaphoreValueCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphoreValues, object.waitSemaphoreValueCount, "const uint64_t*", "pWaitSemaphoreValues", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.signalSemaphoreValueCount, "uint32_t", "signalSemaphoreValueCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSignalSemaphoreValues, object.signalSemaphoreValueCount, "const uint64_t*", "pSignalSemaphoreValues", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreWaitInfo(ApiDumpInstance& api_dump, const VkSemaphoreWaitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphoreWaitFlags(api_dump, object.flags, "VkSemaphoreWaitFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.semaphoreCount, "uint32_t", "semaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSemaphores, object.semaphoreCount, "const VkSemaphore*", "pSemaphores", "const VkSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pValues, object.semaphoreCount, "const uint64_t*", "pValues", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreSignalInfo(ApiDumpInstance& api_dump, const VkSemaphoreSignalInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.value, "uint64_t", "value", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceBufferDeviceAddressFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceBufferDeviceAddressFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddress, "VkBool32", "bufferDeviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddressCaptureReplay, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddressMultiDevice, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferDeviceAddressInfo(ApiDumpInstance& api_dump, const VkBufferDeviceAddressInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferOpaqueCaptureAddressCreateInfo(ApiDumpInstance& api_dump, const VkBufferOpaqueCaptureAddressCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.opaqueCaptureAddress, "uint64_t", "opaqueCaptureAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryOpaqueCaptureAddressAllocateInfo(ApiDumpInstance& api_dump, const VkMemoryOpaqueCaptureAddressAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.opaqueCaptureAddress, "uint64_t", "opaqueCaptureAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceMemoryOpaqueCaptureAddressInfo(ApiDumpInstance& api_dump, const VkDeviceMemoryOpaqueCaptureAddressInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevice8BitStorageFeatures(ApiDumpInstance& api_dump, const VkPhysicalDevice8BitStorageFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageBuffer8BitAccess, "VkBool32", "storageBuffer8BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformAndStorageBuffer8BitAccess, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storagePushConstant8, "VkBool32", "storagePushConstant8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderAtomicInt64Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderAtomicInt64Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferInt64Atomics, "VkBool32", "shaderBufferInt64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedInt64Atomics, "VkBool32", "shaderSharedInt64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderFloat16Int8Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderFloat16Int8Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloat16, "VkBool32", "shaderFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInt8, "VkBool32", "shaderInt8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFloatControlsProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceFloatControlsProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderFloatControlsIndependence(api_dump, object.denormBehaviorIndependence, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderFloatControlsIndependence(api_dump, object.roundingModeIndependence, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSignedZeroInfNanPreserveFloat16, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSignedZeroInfNanPreserveFloat32, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSignedZeroInfNanPreserveFloat64, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormPreserveFloat16, "VkBool32", "shaderDenormPreserveFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormPreserveFloat32, "VkBool32", "shaderDenormPreserveFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormPreserveFloat64, "VkBool32", "shaderDenormPreserveFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormFlushToZeroFloat16, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormFlushToZeroFloat32, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDenormFlushToZeroFloat64, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTEFloat16, "VkBool32", "shaderRoundingModeRTEFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTEFloat32, "VkBool32", "shaderRoundingModeRTEFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTEFloat64, "VkBool32", "shaderRoundingModeRTEFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTZFloat16, "VkBool32", "shaderRoundingModeRTZFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTZFloat32, "VkBool32", "shaderRoundingModeRTZFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRoundingModeRTZFloat64, "VkBool32", "shaderRoundingModeRTZFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetLayoutBindingFlagsCreateInfo(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutBindingFlagsCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bindingCount, "uint32_t", "bindingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBindingFlags, object.bindingCount, "const VkDescriptorBindingFlags*", "pBindingFlags", "const VkDescriptorBindingFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorBindingFlags);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorIndexingFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorIndexingFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInputAttachmentArrayDynamicIndexing, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformTexelBufferArrayDynamicIndexing, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTexelBufferArrayDynamicIndexing, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformBufferArrayNonUniformIndexing, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSampledImageArrayNonUniformIndexing, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageBufferArrayNonUniformIndexing, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageArrayNonUniformIndexing, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInputAttachmentArrayNonUniformIndexing, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformTexelBufferArrayNonUniformIndexing, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTexelBufferArrayNonUniformIndexing, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingUniformBufferUpdateAfterBind, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingSampledImageUpdateAfterBind, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageImageUpdateAfterBind, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageBufferUpdateAfterBind, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingUniformTexelBufferUpdateAfterBind, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageTexelBufferUpdateAfterBind, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingUpdateUnusedWhilePending, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingPartiallyBound, "VkBool32", "descriptorBindingPartiallyBound", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingVariableDescriptorCount, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.runtimeDescriptorArray, "VkBool32", "runtimeDescriptorArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorIndexingProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorIndexingProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxUpdateAfterBindDescriptorsInAllPools, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformBufferArrayNonUniformIndexingNative, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSampledImageArrayNonUniformIndexingNative, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageBufferArrayNonUniformIndexingNative, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageImageArrayNonUniformIndexingNative, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderInputAttachmentArrayNonUniformIndexingNative, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustBufferAccessUpdateAfterBind, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.quadDivergentImplicitLod, "VkBool32", "quadDivergentImplicitLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindSamplers, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindSampledImages, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindStorageImages, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindInputAttachments, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageUpdateAfterBindResources, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindSamplers, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindUniformBuffers, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageBuffers, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindSampledImages, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageImages, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindInputAttachments, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetVariableDescriptorCountAllocateInfo(ApiDumpInstance& api_dump, const VkDescriptorSetVariableDescriptorCountAllocateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorSetCount, "uint32_t", "descriptorSetCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDescriptorCounts, object.descriptorSetCount, "const uint32_t*", "pDescriptorCounts", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetVariableDescriptorCountLayoutSupport(ApiDumpInstance& api_dump, const VkDescriptorSetVariableDescriptorCountLayoutSupport& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVariableDescriptorCount, "uint32_t", "maxVariableDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceScalarBlockLayoutFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceScalarBlockLayoutFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.scalarBlockLayout, "VkBool32", "scalarBlockLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerReductionModeCreateInfo(ApiDumpInstance& api_dump, const VkSamplerReductionModeCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerReductionMode(api_dump, object.reductionMode, "VkSamplerReductionMode", "reductionMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSamplerFilterMinmaxProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceSamplerFilterMinmaxProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filterMinmaxSingleComponentFormats, "VkBool32", "filterMinmaxSingleComponentFormats", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filterMinmaxImageComponentMapping, "VkBool32", "filterMinmaxImageComponentMapping", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformBufferStandardLayout, "VkBool32", "uniformBufferStandardLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupExtendedTypes, "VkBool32", "shaderSubgroupExtendedTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentDescription2(ApiDumpInstance& api_dump, const VkAttachmentDescription2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentDescriptionFlags(api_dump, object.flags, "VkAttachmentDescriptionFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.samples, "VkSampleCountFlagBits", "samples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentLoadOp(api_dump, object.loadOp, "VkAttachmentLoadOp", "loadOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentStoreOp(api_dump, object.storeOp, "VkAttachmentStoreOp", "storeOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentLoadOp(api_dump, object.stencilLoadOp, "VkAttachmentLoadOp", "stencilLoadOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentStoreOp(api_dump, object.stencilStoreOp, "VkAttachmentStoreOp", "stencilStoreOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.initialLayout, "VkImageLayout", "initialLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.finalLayout, "VkImageLayout", "finalLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentReference2(ApiDumpInstance& api_dump, const VkAttachmentReference2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachment, "uint32_t", "attachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.layout, "VkImageLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlags(api_dump, object.aspectMask, "VkImageAspectFlags", "aspectMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassDescription2(ApiDumpInstance& api_dump, const VkSubpassDescription2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSubpassDescriptionFlags(api_dump, object.flags, "VkSubpassDescriptionFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewMask, "uint32_t", "viewMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.inputAttachmentCount, "uint32_t", "inputAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pInputAttachments, object.inputAttachmentCount, "const VkAttachmentReference2*", "pInputAttachments", "const VkAttachmentReference2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachments, object.colorAttachmentCount, "const VkAttachmentReference2*", "pColorAttachments", "const VkAttachmentReference2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pResolveAttachments, object.colorAttachmentCount, "const VkAttachmentReference2*", "pResolveAttachments", "const VkAttachmentReference2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthStencilAttachment, "const VkAttachmentReference2*", "pDepthStencilAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preserveAttachmentCount, "uint32_t", "preserveAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPreserveAttachments, object.preserveAttachmentCount, "const uint32_t*", "pPreserveAttachments", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassDependency2(ApiDumpInstance& api_dump, const VkSubpassDependency2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcSubpass, "uint32_t", "srcSubpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstSubpass, "uint32_t", "dstSubpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags(api_dump, object.srcStageMask, "VkPipelineStageFlags", "srcStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags(api_dump, object.dstStageMask, "VkPipelineStageFlags", "dstStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.srcAccessMask, "VkAccessFlags", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags(api_dump, object.dstAccessMask, "VkAccessFlags", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDependencyFlags(api_dump, object.dependencyFlags, "VkDependencyFlags", "dependencyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.viewOffset, "int32_t", "viewOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassCreateInfo2(ApiDumpInstance& api_dump, const VkRenderPassCreateInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPassCreateFlags(api_dump, object.flags, "VkRenderPassCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentCount, "uint32_t", "attachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachments, object.attachmentCount, "const VkAttachmentDescription2*", "pAttachments", "const VkAttachmentDescription2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentDescription2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subpassCount, "uint32_t", "subpassCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSubpasses, object.subpassCount, "const VkSubpassDescription2*", "pSubpasses", "const VkSubpassDescription2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDescription2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dependencyCount, "uint32_t", "dependencyCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDependencies, object.dependencyCount, "const VkSubpassDependency2*", "pDependencies", "const VkSubpassDependency2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDependency2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.correlatedViewMaskCount, "uint32_t", "correlatedViewMaskCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCorrelatedViewMasks, object.correlatedViewMaskCount, "const uint32_t*", "pCorrelatedViewMasks", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassBeginInfo(ApiDumpInstance& api_dump, const VkSubpassBeginInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSubpassContents(api_dump, object.contents, "VkSubpassContents", "contents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassEndInfo(ApiDumpInstance& api_dump, const VkSubpassEndInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassDescriptionDepthStencilResolve(ApiDumpInstance& api_dump, const VkSubpassDescriptionDepthStencilResolve& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlagBits(api_dump, object.depthResolveMode, "VkResolveModeFlagBits", "depthResolveMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlagBits(api_dump, object.stencilResolveMode, "VkResolveModeFlagBits", "stencilResolveMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthStencilResolveAttachment, "const VkAttachmentReference2*", "pDepthStencilResolveAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDepthStencilResolveProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceDepthStencilResolveProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlags(api_dump, object.supportedDepthResolveModes, "VkResolveModeFlags", "supportedDepthResolveModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlags(api_dump, object.supportedStencilResolveModes, "VkResolveModeFlags", "supportedStencilResolveModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.independentResolveNone, "VkBool32", "independentResolveNone", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.independentResolve, "VkBool32", "independentResolve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageStencilUsageCreateInfo(ApiDumpInstance& api_dump, const VkImageStencilUsageCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.stencilUsage, "VkImageUsageFlags", "stencilUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImagelessFramebufferFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceImagelessFramebufferFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imagelessFramebuffer, "VkBool32", "imagelessFramebuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFramebufferAttachmentImageInfo(ApiDumpInstance& api_dump, const VkFramebufferAttachmentImageInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCreateFlags(api_dump, object.flags, "VkImageCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.usage, "VkImageUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layerCount, "uint32_t", "layerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewFormatCount, "uint32_t", "viewFormatCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pViewFormats, object.viewFormatCount, "const VkFormat*", "pViewFormats", "const VkFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFramebufferAttachmentsCreateInfo(ApiDumpInstance& api_dump, const VkFramebufferAttachmentsCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentImageInfoCount, "uint32_t", "attachmentImageInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachmentImageInfos, object.attachmentImageInfoCount, "const VkFramebufferAttachmentImageInfo*", "pAttachmentImageInfos", "const VkFramebufferAttachmentImageInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFramebufferAttachmentImageInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassAttachmentBeginInfo(ApiDumpInstance& api_dump, const VkRenderPassAttachmentBeginInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentCount, "uint32_t", "attachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachments, object.attachmentCount, "const VkImageView*", "pAttachments", "const VkImageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageView);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.separateDepthStencilLayouts, "VkBool32", "separateDepthStencilLayouts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentReferenceStencilLayout(ApiDumpInstance& api_dump, const VkAttachmentReferenceStencilLayout& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.stencilLayout, "VkImageLayout", "stencilLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentDescriptionStencilLayout(ApiDumpInstance& api_dump, const VkAttachmentDescriptionStencilLayout& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.stencilInitialLayout, "VkImageLayout", "stencilInitialLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.stencilFinalLayout, "VkImageLayout", "stencilFinalLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan13Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan13Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustImageAccess, "VkBool32", "robustImageAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.inlineUniformBlock, "VkBool32", "inlineUniformBlock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingInlineUniformBlockUpdateAfterBind, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineCreationCacheControl, "VkBool32", "pipelineCreationCacheControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.privateData, "VkBool32", "privateData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDemoteToHelperInvocation, "VkBool32", "shaderDemoteToHelperInvocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTerminateInvocation, "VkBool32", "shaderTerminateInvocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subgroupSizeControl, "VkBool32", "subgroupSizeControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.computeFullSubgroups, "VkBool32", "computeFullSubgroups", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.synchronization2, "VkBool32", "synchronization2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureCompressionASTC_HDR, "VkBool32", "textureCompressionASTC_HDR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderZeroInitializeWorkgroupMemory, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRendering, "VkBool32", "dynamicRendering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderIntegerDotProduct, "VkBool32", "shaderIntegerDotProduct", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance4, "VkBool32", "maintenance4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan13Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan13Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minSubgroupSize, "uint32_t", "minSubgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSubgroupSize, "uint32_t", "maxSubgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxComputeWorkgroupSubgroups, "uint32_t", "maxComputeWorkgroupSubgroups", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.requiredSubgroupSizeStages, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInlineUniformBlockSize, "uint32_t", "maxInlineUniformBlockSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorInlineUniformBlocks, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetInlineUniformBlocks, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInlineUniformTotalSize, "uint32_t", "maxInlineUniformTotalSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct8BitUnsignedAccelerated, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct8BitSignedAccelerated, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct8BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct4x8BitPackedUnsignedAccelerated, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct4x8BitPackedSignedAccelerated, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct16BitUnsignedAccelerated, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct16BitSignedAccelerated, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct16BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct32BitUnsignedAccelerated, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct32BitSignedAccelerated, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct32BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct64BitUnsignedAccelerated, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct64BitSignedAccelerated, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct64BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.storageTexelBufferOffsetAlignmentBytes, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageTexelBufferOffsetSingleTexelAlignment, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.uniformTexelBufferOffsetAlignmentBytes, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformTexelBufferOffsetSingleTexelAlignment, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxBufferSize, "VkDeviceSize", "maxBufferSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceToolProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceToolProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_EXTENSION_NAME_SIZE]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.version, "char[VK_MAX_EXTENSION_NAME_SIZE]", "version", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkToolPurposeFlags(api_dump, object.purposes, "VkToolPurposeFlags", "purposes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.layer, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePrivateDataFeatures(ApiDumpInstance& api_dump, const VkPhysicalDevicePrivateDataFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.privateData, "VkBool32", "privateData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDevicePrivateDataCreateInfo(ApiDumpInstance& api_dump, const VkDevicePrivateDataCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.privateDataSlotRequestCount, "uint32_t", "privateDataSlotRequestCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPrivateDataSlotCreateInfo(ApiDumpInstance& api_dump, const VkPrivateDataSlotCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPrivateDataSlotCreateFlags(api_dump, object.flags, "VkPrivateDataSlotCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryBarrier2(ApiDumpInstance& api_dump, const VkMemoryBarrier2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.srcStageMask, "VkPipelineStageFlags2", "srcStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.srcAccessMask, "VkAccessFlags2", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.dstStageMask, "VkPipelineStageFlags2", "dstStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.dstAccessMask, "VkAccessFlags2", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferMemoryBarrier2(ApiDumpInstance& api_dump, const VkBufferMemoryBarrier2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.srcStageMask, "VkPipelineStageFlags2", "srcStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.srcAccessMask, "VkAccessFlags2", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.dstStageMask, "VkPipelineStageFlags2", "dstStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.dstAccessMask, "VkAccessFlags2", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcQueueFamilyIndex, "uint32_t", "srcQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstQueueFamilyIndex, "uint32_t", "dstQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageMemoryBarrier2(ApiDumpInstance& api_dump, const VkImageMemoryBarrier2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.srcStageMask, "VkPipelineStageFlags2", "srcStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.srcAccessMask, "VkAccessFlags2", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.dstStageMask, "VkPipelineStageFlags2", "dstStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.dstAccessMask, "VkAccessFlags2", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.oldLayout, "VkImageLayout", "oldLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.newLayout, "VkImageLayout", "newLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcQueueFamilyIndex, "uint32_t", "srcQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstQueueFamilyIndex, "uint32_t", "dstQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceRange(api_dump, object.subresourceRange, "VkImageSubresourceRange", "subresourceRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDependencyInfo(ApiDumpInstance& api_dump, const VkDependencyInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDependencyFlags(api_dump, object.dependencyFlags, "VkDependencyFlags", "dependencyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryBarrierCount, "uint32_t", "memoryBarrierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pMemoryBarriers, object.memoryBarrierCount, "const VkMemoryBarrier2*", "pMemoryBarriers", "const VkMemoryBarrier2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryBarrier2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferMemoryBarrierCount, "uint32_t", "bufferMemoryBarrierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBufferMemoryBarriers, object.bufferMemoryBarrierCount, "const VkBufferMemoryBarrier2*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferMemoryBarrier2);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageMemoryBarrierCount, "uint32_t", "imageMemoryBarrierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImageMemoryBarriers, object.imageMemoryBarrierCount, "const VkImageMemoryBarrier2*", "pImageMemoryBarriers", "const VkImageMemoryBarrier2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageMemoryBarrier2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreSubmitInfo(ApiDumpInstance& api_dump, const VkSemaphoreSubmitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.value, "uint64_t", "value", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.stageMask, "VkPipelineStageFlags2", "stageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceIndex, "uint32_t", "deviceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferSubmitInfo(ApiDumpInstance& api_dump, const VkCommandBufferSubmitInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCommandBuffer(api_dump, object.commandBuffer, "VkCommandBuffer", "commandBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceMask, "uint32_t", "deviceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubmitInfo2(ApiDumpInstance& api_dump, const VkSubmitInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSubmitFlags(api_dump, object.flags, "VkSubmitFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreInfoCount, "uint32_t", "waitSemaphoreInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphoreInfos, object.waitSemaphoreInfoCount, "const VkSemaphoreSubmitInfo*", "pWaitSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.commandBufferInfoCount, "uint32_t", "commandBufferInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCommandBufferInfos, object.commandBufferInfoCount, "const VkCommandBufferSubmitInfo*", "pCommandBufferInfos", "const VkCommandBufferSubmitInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBufferSubmitInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.signalSemaphoreInfoCount, "uint32_t", "signalSemaphoreInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSignalSemaphoreInfos, object.signalSemaphoreInfoCount, "const VkSemaphoreSubmitInfo*", "pSignalSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSynchronization2Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceSynchronization2Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.synchronization2, "VkBool32", "synchronization2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCopy2(ApiDumpInstance& api_dump, const VkBufferCopy2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.srcOffset, "VkDeviceSize", "srcOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.dstOffset, "VkDeviceSize", "dstOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyBufferInfo2(ApiDumpInstance& api_dump, const VkCopyBufferInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.srcBuffer, "VkBuffer", "srcBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.dstBuffer, "VkBuffer", "dstBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkBufferCopy2*", "pRegions", "const VkBufferCopy2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferCopy2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageCopy2(ApiDumpInstance& api_dump, const VkImageCopy2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.srcSubresource, "VkImageSubresourceLayers", "srcSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.srcOffset, "VkOffset3D", "srcOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.dstSubresource, "VkImageSubresourceLayers", "dstSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.dstOffset, "VkOffset3D", "dstOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.extent, "VkExtent3D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyImageInfo2(ApiDumpInstance& api_dump, const VkCopyImageInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.srcImage, "VkImage", "srcImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.srcImageLayout, "VkImageLayout", "srcImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkImageCopy2*", "pRegions", "const VkImageCopy2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCopy2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferImageCopy2(ApiDumpInstance& api_dump, const VkBufferImageCopy2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.bufferOffset, "VkDeviceSize", "bufferOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferRowLength, "uint32_t", "bufferRowLength", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferImageHeight, "uint32_t", "bufferImageHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.imageSubresource, "VkImageSubresourceLayers", "imageSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.imageOffset, "VkOffset3D", "imageOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.imageExtent, "VkExtent3D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyBufferToImageInfo2(ApiDumpInstance& api_dump, const VkCopyBufferToImageInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.srcBuffer, "VkBuffer", "srcBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkBufferImageCopy2*", "pRegions", "const VkBufferImageCopy2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferImageCopy2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyImageToBufferInfo2(ApiDumpInstance& api_dump, const VkCopyImageToBufferInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.srcImage, "VkImage", "srcImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.srcImageLayout, "VkImageLayout", "srcImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.dstBuffer, "VkBuffer", "dstBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkBufferImageCopy2*", "pRegions", "const VkBufferImageCopy2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferImageCopy2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureCompressionASTC_HDR, "VkBool32", "textureCompressionASTC_HDR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFormatProperties3(ApiDumpInstance& api_dump, const VkFormatProperties3& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.linearTilingFeatures, "VkFormatFeatureFlags2", "linearTilingFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.optimalTilingFeatures, "VkFormatFeatureFlags2", "optimalTilingFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.bufferFeatures, "VkFormatFeatureFlags2", "bufferFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance4Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance4Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance4, "VkBool32", "maintenance4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance4Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance4Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxBufferSize, "VkDeviceSize", "maxBufferSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceBufferMemoryRequirements(ApiDumpInstance& api_dump, const VkDeviceBufferMemoryRequirements& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCreateInfo, "const VkBufferCreateInfo*", "pCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferCreateInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceImageMemoryRequirements(ApiDumpInstance& api_dump, const VkDeviceImageMemoryRequirements& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCreateInfo, "const VkImageCreateInfo*", "pCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlagBits(api_dump, object.planeAspect, "VkImageAspectFlagBits", "planeAspect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCreationFeedback(ApiDumpInstance& api_dump, const VkPipelineCreationFeedback& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPipelineCreationFeedbackFlags(api_dump, object.flags, "VkPipelineCreationFeedbackFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.duration, "uint64_t", "duration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCreationFeedbackCreateInfo(ApiDumpInstance& api_dump, const VkPipelineCreationFeedbackCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pPipelineCreationFeedback, "VkPipelineCreationFeedback*", "pPipelineCreationFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreationFeedback);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pipelineStageCreationFeedbackCount, "uint32_t", "pipelineStageCreationFeedbackCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPipelineStageCreationFeedbacks, object.pipelineStageCreationFeedbackCount, "VkPipelineCreationFeedback*", "pPipelineStageCreationFeedbacks", "VkPipelineCreationFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreationFeedback);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderTerminateInvocationFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderTerminateInvocationFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTerminateInvocation, "VkBool32", "shaderTerminateInvocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDemoteToHelperInvocation, "VkBool32", "shaderDemoteToHelperInvocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineCreationCacheControlFeatures(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineCreationCacheControlFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineCreationCacheControl, "VkBool32", "pipelineCreationCacheControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderZeroInitializeWorkgroupMemory, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageRobustnessFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageRobustnessFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustImageAccess, "VkBool32", "robustImageAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSubgroupSizeControlFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceSubgroupSizeControlFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subgroupSizeControl, "VkBool32", "subgroupSizeControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.computeFullSubgroups, "VkBool32", "computeFullSubgroups", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSubgroupSizeControlProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceSubgroupSizeControlProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minSubgroupSize, "uint32_t", "minSubgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSubgroupSize, "uint32_t", "maxSubgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxComputeWorkgroupSubgroups, "uint32_t", "maxComputeWorkgroupSubgroups", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.requiredSubgroupSizeStages, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(ApiDumpInstance& api_dump, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.requiredSubgroupSize, "uint32_t", "requiredSubgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceInlineUniformBlockFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceInlineUniformBlockFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.inlineUniformBlock, "VkBool32", "inlineUniformBlock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingInlineUniformBlockUpdateAfterBind, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceInlineUniformBlockProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceInlineUniformBlockProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInlineUniformBlockSize, "uint32_t", "maxInlineUniformBlockSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorInlineUniformBlocks, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetInlineUniformBlocks, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteDescriptorSetInlineUniformBlock(ApiDumpInstance& api_dump, const VkWriteDescriptorSetInlineUniformBlock& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dataSize, "uint32_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pData, "const void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorPoolInlineUniformBlockCreateInfo(ApiDumpInstance& api_dump, const VkDescriptorPoolInlineUniformBlockCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInlineUniformBlockBindings, "uint32_t", "maxInlineUniformBlockBindings", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderIntegerDotProductFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderIntegerDotProductFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderIntegerDotProduct, "VkBool32", "shaderIntegerDotProduct", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderIntegerDotProductProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderIntegerDotProductProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct8BitUnsignedAccelerated, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct8BitSignedAccelerated, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct8BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct4x8BitPackedUnsignedAccelerated, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct4x8BitPackedSignedAccelerated, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct16BitUnsignedAccelerated, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct16BitSignedAccelerated, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct16BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct32BitUnsignedAccelerated, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct32BitSignedAccelerated, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct32BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct64BitUnsignedAccelerated, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct64BitSignedAccelerated, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProduct64BitMixedSignednessAccelerated, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTexelBufferAlignmentProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceTexelBufferAlignmentProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.storageTexelBufferOffsetAlignmentBytes, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.storageTexelBufferOffsetSingleTexelAlignment, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.uniformTexelBufferOffsetAlignmentBytes, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.uniformTexelBufferOffsetSingleTexelAlignment, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageBlit2(ApiDumpInstance& api_dump, const VkImageBlit2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.srcSubresource, "VkImageSubresourceLayers", "srcSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.srcOffsets, 2, "VkOffset3D[2]", "srcOffsets", "VkOffset3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D);
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.dstSubresource, "VkImageSubresourceLayers", "dstSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.dstOffsets, 2, "VkOffset3D[2]", "dstOffsets", "VkOffset3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBlitImageInfo2(ApiDumpInstance& api_dump, const VkBlitImageInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.srcImage, "VkImage", "srcImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.srcImageLayout, "VkImageLayout", "srcImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkImageBlit2*", "pRegions", "const VkImageBlit2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageBlit2);
+    dump_separate_members(api_dump);
+    dump_VkFilter(api_dump, object.filter, "VkFilter", "filter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageResolve2(ApiDumpInstance& api_dump, const VkImageResolve2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.srcSubresource, "VkImageSubresourceLayers", "srcSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.srcOffset, "VkOffset3D", "srcOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.dstSubresource, "VkImageSubresourceLayers", "dstSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.dstOffset, "VkOffset3D", "dstOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.extent, "VkExtent3D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkResolveImageInfo2(ApiDumpInstance& api_dump, const VkResolveImageInfo2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.srcImage, "VkImage", "srcImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.srcImageLayout, "VkImageLayout", "srcImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkImageResolve2*", "pRegions", "const VkImageResolve2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageResolve2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingAttachmentInfo(ApiDumpInstance& api_dump, const VkRenderingAttachmentInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.imageLayout, "VkImageLayout", "imageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlagBits(api_dump, object.resolveMode, "VkResolveModeFlagBits", "resolveMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.resolveImageView, "VkImageView", "resolveImageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.resolveImageLayout, "VkImageLayout", "resolveImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentLoadOp(api_dump, object.loadOp, "VkAttachmentLoadOp", "loadOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentStoreOp(api_dump, object.storeOp, "VkAttachmentStoreOp", "storeOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClearValue(api_dump, object.clearValue, "VkClearValue", "clearValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingInfo(ApiDumpInstance& api_dump, const VkRenderingInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderingFlags(api_dump, object.flags, "VkRenderingFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRect2D(api_dump, object.renderArea, "VkRect2D", "renderArea", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layerCount, "uint32_t", "layerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewMask, "uint32_t", "viewMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachments, object.colorAttachmentCount, "const VkRenderingAttachmentInfo*", "pColorAttachments", "const VkRenderingAttachmentInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthAttachment, "const VkRenderingAttachmentInfo*", "pDepthAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStencilAttachment, "const VkRenderingAttachmentInfo*", "pStencilAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRenderingCreateInfo(ApiDumpInstance& api_dump, const VkPipelineRenderingCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewMask, "uint32_t", "viewMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    if (!api_dump.getIsGPLPreRasterOrFragmentShader()) {
+        dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "uint32_t", "colorAttachmentCount", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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>);
+    dump_separate_members(api_dump);
+    if (!api_dump.getIsGPLPreRasterOrFragmentShader()) {
+        dump_pointer_array(api_dump, object.pColorAttachmentFormats, object.colorAttachmentCount, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat);
     } 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const VkFormat*", "pColorAttachmentFormats", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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));
+    dump_separate_members(api_dump);
+    if (!api_dump.getIsGPLPreRasterOrFragmentShader()) {
+        dump_VkFormat(api_dump, object.depthAttachmentFormat, "VkFormat", "depthAttachmentFormat", indents + (api_dump.settings().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);
+        if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "VkFormat", "depthAttachmentFormat", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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));
+    dump_separate_members(api_dump);
+    if (!api_dump.getIsGPLPreRasterOrFragmentShader()) {
+        dump_VkFormat(api_dump, object.stencilAttachmentFormat, "VkFormat", "stencilAttachmentFormat", indents + (api_dump.settings().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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "VkFormat", "stencilAttachmentFormat", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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_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_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_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 (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDynamicRenderingFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceDynamicRenderingFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRendering, "VkBool32", "dynamicRendering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferInheritanceRenderingInfo(ApiDumpInstance& api_dump, const VkCommandBufferInheritanceRenderingInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderingFlags(api_dump, object.flags, "VkRenderingFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewMask, "uint32_t", "viewMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachmentFormats, object.colorAttachmentCount, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat);
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.depthAttachmentFormat, "VkFormat", "depthAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.stencilAttachmentFormat, "VkFormat", "stencilAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.rasterizationSamples, "VkSampleCountFlagBits", "rasterizationSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan14Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan14Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.globalPriorityQuery, "VkBool32", "globalPriorityQuery", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupRotate, "VkBool32", "shaderSubgroupRotate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupRotateClustered, "VkBool32", "shaderSubgroupRotateClustered", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloatControls2, "VkBool32", "shaderFloatControls2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderExpectAssume, "VkBool32", "shaderExpectAssume", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rectangularLines, "VkBool32", "rectangularLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bresenhamLines, "VkBool32", "bresenhamLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.smoothLines, "VkBool32", "smoothLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledRectangularLines, "VkBool32", "stippledRectangularLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledBresenhamLines, "VkBool32", "stippledBresenhamLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledSmoothLines, "VkBool32", "stippledSmoothLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexAttributeInstanceRateDivisor, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexAttributeInstanceRateZeroDivisor, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.indexTypeUint8, "VkBool32", "indexTypeUint8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRenderingLocalRead, "VkBool32", "dynamicRenderingLocalRead", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance5, "VkBool32", "maintenance5", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance6, "VkBool32", "maintenance6", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineProtectedAccess, "VkBool32", "pipelineProtectedAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineRobustness, "VkBool32", "pipelineRobustness", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hostImageCopy, "VkBool32", "hostImageCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pushDescriptor, "VkBool32", "pushDescriptor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVulkan14Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceVulkan14Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.lineSubPixelPrecisionBits, "uint32_t", "lineSubPixelPrecisionBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexAttribDivisor, "uint32_t", "maxVertexAttribDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.supportsNonZeroFirstInstance, "VkBool32", "supportsNonZeroFirstInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPushDescriptors, "uint32_t", "maxPushDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRenderingLocalReadDepthStencilAttachments, "VkBool32", "dynamicRenderingLocalReadDepthStencilAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRenderingLocalReadMultisampledAttachments, "VkBool32", "dynamicRenderingLocalReadMultisampledAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.earlyFragmentMultisampleCoverageAfterSampleCounting, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.earlyFragmentSampleMaskTestBeforeSampleCounting, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthStencilSwizzleOneSupport, "VkBool32", "depthStencilSwizzleOneSupport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.polygonModePointSize, "VkBool32", "polygonModePointSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nonStrictSinglePixelWideLinesUseParallelogram, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nonStrictWideLinesUseParallelogram, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.blockTexelViewCompatibleMultipleLayers, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCombinedImageSamplerDescriptorCount, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateClampCombinerInputs, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.defaultRobustnessStorageBuffers, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.defaultRobustnessUniformBuffers, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.defaultRobustnessVertexInputs, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessImageBehavior(api_dump, object.defaultRobustnessImages, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.copySrcLayoutCount, "uint32_t", "copySrcLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCopySrcLayouts, object.copySrcLayoutCount, "VkImageLayout*", "pCopySrcLayouts", "VkImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.copyDstLayoutCount, "uint32_t", "copyDstLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCopyDstLayouts, object.copyDstLayoutCount, "VkImageLayout*", "pCopyDstLayouts", "VkImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.optimalTilingLayoutUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "optimalTilingLayoutUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.identicalMemoryTypeRequirements, "VkBool32", "identicalMemoryTypeRequirements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceQueueGlobalPriorityCreateInfo(ApiDumpInstance& api_dump, const VkDeviceQueueGlobalPriorityCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueueGlobalPriority(api_dump, object.globalPriority, "VkQueueGlobalPriority", "globalPriority", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceGlobalPriorityQueryFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceGlobalPriorityQueryFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.globalPriorityQuery, "VkBool32", "globalPriorityQuery", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyGlobalPriorityProperties(ApiDumpInstance& api_dump, const VkQueueFamilyGlobalPriorityProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.priorityCount, "uint32_t", "priorityCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.priorities, std::min(object.priorityCount, VK_MAX_GLOBAL_PRIORITY_SIZE), "VkQueueGlobalPriority[VK_MAX_GLOBAL_PRIORITY_SIZE]", "priorities", "VkQueueGlobalPriority", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkQueueGlobalPriority);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceIndexTypeUint8Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceIndexTypeUint8Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.indexTypeUint8, "VkBool32", "indexTypeUint8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryMapInfo(ApiDumpInstance& api_dump, const VkMemoryMapInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryMapFlags(api_dump, object.flags, "VkMemoryMapFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryUnmapInfo(ApiDumpInstance& api_dump, const VkMemoryUnmapInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryUnmapFlags(api_dump, object.flags, "VkMemoryUnmapFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance5Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance5Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance5, "VkBool32", "maintenance5", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance5Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance5Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.earlyFragmentMultisampleCoverageAfterSampleCounting, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.earlyFragmentSampleMaskTestBeforeSampleCounting, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthStencilSwizzleOneSupport, "VkBool32", "depthStencilSwizzleOneSupport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.polygonModePointSize, "VkBool32", "polygonModePointSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nonStrictSinglePixelWideLinesUseParallelogram, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nonStrictWideLinesUseParallelogram, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageSubresource2(ApiDumpInstance& api_dump, const VkImageSubresource2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresource(api_dump, object.imageSubresource, "VkImageSubresource", "imageSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceImageSubresourceInfo(ApiDumpInstance& api_dump, const VkDeviceImageSubresourceInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCreateInfo, "const VkImageCreateInfo*", "pCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSubresource, "const VkImageSubresource2*", "pSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageSubresource2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubresourceLayout2(ApiDumpInstance& api_dump, const VkSubresourceLayout2& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSubresourceLayout(api_dump, object.subresourceLayout, "VkSubresourceLayout", "subresourceLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferUsageFlags2CreateInfo(ApiDumpInstance& api_dump, const VkBufferUsageFlags2CreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferUsageFlags2(api_dump, object.usage, "VkBufferUsageFlags2", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance6Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance6Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance6, "VkBool32", "maintenance6", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance6Properties(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance6Properties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.blockTexelViewCompatibleMultipleLayers, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCombinedImageSamplerDescriptorCount, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateClampCombinerInputs, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindMemoryStatus(ApiDumpInstance& api_dump, const VkBindMemoryStatus& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pResult, "VkResult*", "pResult", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkResult);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceHostImageCopyFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceHostImageCopyFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hostImageCopy, "VkBool32", "hostImageCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceHostImageCopyProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceHostImageCopyProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.copySrcLayoutCount, "uint32_t", "copySrcLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCopySrcLayouts, object.copySrcLayoutCount, "VkImageLayout*", "pCopySrcLayouts", "VkImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.copyDstLayoutCount, "uint32_t", "copyDstLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCopyDstLayouts, object.copyDstLayoutCount, "VkImageLayout*", "pCopyDstLayouts", "VkImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.optimalTilingLayoutUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "optimalTilingLayoutUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.identicalMemoryTypeRequirements, "VkBool32", "identicalMemoryTypeRequirements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryToImageCopy(ApiDumpInstance& api_dump, const VkMemoryToImageCopy& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pHostPointer, "const void*", "pHostPointer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryRowLength, "uint32_t", "memoryRowLength", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryImageHeight, "uint32_t", "memoryImageHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.imageSubresource, "VkImageSubresourceLayers", "imageSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.imageOffset, "VkOffset3D", "imageOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.imageExtent, "VkExtent3D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageToMemoryCopy(ApiDumpInstance& api_dump, const VkImageToMemoryCopy& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pHostPointer, "void*", "pHostPointer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryRowLength, "uint32_t", "memoryRowLength", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryImageHeight, "uint32_t", "memoryImageHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.imageSubresource, "VkImageSubresourceLayers", "imageSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.imageOffset, "VkOffset3D", "imageOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.imageExtent, "VkExtent3D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryToImageInfo(ApiDumpInstance& api_dump, const VkCopyMemoryToImageInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkHostImageCopyFlags(api_dump, object.flags, "VkHostImageCopyFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkMemoryToImageCopy*", "pRegions", "const VkMemoryToImageCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryToImageCopy);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyImageToMemoryInfo(ApiDumpInstance& api_dump, const VkCopyImageToMemoryInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkHostImageCopyFlags(api_dump, object.flags, "VkHostImageCopyFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.srcImage, "VkImage", "srcImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.srcImageLayout, "VkImageLayout", "srcImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkImageToMemoryCopy*", "pRegions", "const VkImageToMemoryCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageToMemoryCopy);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyImageToImageInfo(ApiDumpInstance& api_dump, const VkCopyImageToImageInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkHostImageCopyFlags(api_dump, object.flags, "VkHostImageCopyFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.srcImage, "VkImage", "srcImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.srcImageLayout, "VkImageLayout", "srcImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkImageCopy2*", "pRegions", "const VkImageCopy2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCopy2);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkHostImageLayoutTransitionInfo(ApiDumpInstance& api_dump, const VkHostImageLayoutTransitionInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.oldLayout, "VkImageLayout", "oldLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.newLayout, "VkImageLayout", "newLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceRange(api_dump, object.subresourceRange, "VkImageSubresourceRange", "subresourceRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubresourceHostMemcpySize(ApiDumpInstance& api_dump, const VkSubresourceHostMemcpySize& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkHostImageCopyDevicePerformanceQuery(ApiDumpInstance& api_dump, const VkHostImageCopyDevicePerformanceQuery& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.optimalDeviceAccess, "VkBool32", "optimalDeviceAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.identicalMemoryLayout, "VkBool32", "identicalMemoryLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderSubgroupRotateFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderSubgroupRotateFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupRotate, "VkBool32", "shaderSubgroupRotate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupRotateClustered, "VkBool32", "shaderSubgroupRotateClustered", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderFloatControls2Features(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderFloatControls2Features& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloatControls2, "VkBool32", "shaderFloatControls2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderExpectAssumeFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderExpectAssumeFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderExpectAssume, "VkBool32", "shaderExpectAssume", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCreateFlags2CreateInfo(ApiDumpInstance& api_dump, const VkPipelineCreateFlags2CreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags2(api_dump, object.flags, "VkPipelineCreateFlags2", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePushDescriptorProperties(ApiDumpInstance& api_dump, const VkPhysicalDevicePushDescriptorProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPushDescriptors, "uint32_t", "maxPushDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindDescriptorSetsInfo(ApiDumpInstance& api_dump, const VkBindDescriptorSetsInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstSet, "uint32_t", "firstSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorSetCount, "uint32_t", "descriptorSetCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDescriptorSets, object.descriptorSetCount, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dynamicOffsetCount, "uint32_t", "dynamicOffsetCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDynamicOffsets, object.dynamicOffsetCount, "const uint32_t*", "pDynamicOffsets", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPushConstantsInfo(ApiDumpInstance& api_dump, const VkPushConstantsInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pValues, "const void*", "pValues", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPushDescriptorSetInfo(ApiDumpInstance& api_dump, const VkPushDescriptorSetInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.set, "uint32_t", "set", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorWriteCount, "uint32_t", "descriptorWriteCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDescriptorWrites, object.descriptorWriteCount, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkWriteDescriptorSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPushDescriptorSetWithTemplateInfo(ApiDumpInstance& api_dump, const VkPushDescriptorSetWithTemplateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorUpdateTemplate(api_dump, object.descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.set, "uint32_t", "set", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pData, "const void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineProtectedAccessFeatures(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineProtectedAccessFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineProtectedAccess, "VkBool32", "pipelineProtectedAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineRobustnessFeatures(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineRobustnessFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineRobustness, "VkBool32", "pipelineRobustness", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineRobustnessProperties(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineRobustnessProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.defaultRobustnessStorageBuffers, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.defaultRobustnessUniformBuffers, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.defaultRobustnessVertexInputs, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessImageBehavior(api_dump, object.defaultRobustnessImages, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRobustnessCreateInfo(ApiDumpInstance& api_dump, const VkPipelineRobustnessCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.storageBuffers, "VkPipelineRobustnessBufferBehavior", "storageBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.uniformBuffers, "VkPipelineRobustnessBufferBehavior", "uniformBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessBufferBehavior(api_dump, object.vertexInputs, "VkPipelineRobustnessBufferBehavior", "vertexInputs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRobustnessImageBehavior(api_dump, object.images, "VkPipelineRobustnessImageBehavior", "images", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLineRasterizationFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceLineRasterizationFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rectangularLines, "VkBool32", "rectangularLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bresenhamLines, "VkBool32", "bresenhamLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.smoothLines, "VkBool32", "smoothLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledRectangularLines, "VkBool32", "stippledRectangularLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledBresenhamLines, "VkBool32", "stippledBresenhamLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledSmoothLines, "VkBool32", "stippledSmoothLines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLineRasterizationProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceLineRasterizationProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.lineSubPixelPrecisionBits, "uint32_t", "lineSubPixelPrecisionBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationLineStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineRasterizationLineStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkLineRasterizationMode(api_dump, object.lineRasterizationMode, "VkLineRasterizationMode", "lineRasterizationMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.stippledLineEnable, "VkBool32", "stippledLineEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.lineStippleFactor, "uint32_t", "lineStippleFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.lineStipplePattern, "uint16_t", "lineStipplePattern", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVertexAttributeDivisorProperties(ApiDumpInstance& api_dump, const VkPhysicalDeviceVertexAttributeDivisorProperties& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexAttribDivisor, "uint32_t", "maxVertexAttribDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.supportsNonZeroFirstInstance, "VkBool32", "supportsNonZeroFirstInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVertexInputBindingDivisorDescription(ApiDumpInstance& api_dump, const VkVertexInputBindingDivisorDescription& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.divisor, "uint32_t", "divisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineVertexInputDivisorStateCreateInfo(ApiDumpInstance& api_dump, const VkPipelineVertexInputDivisorStateCreateInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexBindingDivisorCount, "uint32_t", "vertexBindingDivisorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pVertexBindingDivisors, object.vertexBindingDivisorCount, "const VkVertexInputBindingDivisorDescription*", "pVertexBindingDivisors", "const VkVertexInputBindingDivisorDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputBindingDivisorDescription);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVertexAttributeDivisorFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceVertexAttributeDivisorFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexAttributeInstanceRateDivisor, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexAttributeInstanceRateZeroDivisor, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingAreaInfo(ApiDumpInstance& api_dump, const VkRenderingAreaInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewMask, "uint32_t", "viewMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachmentFormats, object.colorAttachmentCount, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat);
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.depthAttachmentFormat, "VkFormat", "depthAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.stencilAttachmentFormat, "VkFormat", "stencilAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(ApiDumpInstance& api_dump, const VkPhysicalDeviceDynamicRenderingLocalReadFeatures& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRenderingLocalRead, "VkBool32", "dynamicRenderingLocalRead", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingAttachmentLocationInfo(ApiDumpInstance& api_dump, const VkRenderingAttachmentLocationInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachmentLocations, object.colorAttachmentCount, "const uint32_t*", "pColorAttachmentLocations", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingInputAttachmentIndexInfo(ApiDumpInstance& api_dump, const VkRenderingInputAttachmentIndexInfo& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachmentInputIndices, object.colorAttachmentCount, "const uint32_t*", "pColorAttachmentInputIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthInputAttachmentIndex, "const uint32_t*", "pDepthInputAttachmentIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStencilInputAttachmentIndex, "const uint32_t*", "pStencilInputAttachmentIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilitiesKHR(ApiDumpInstance& api_dump, const VkSurfaceCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.minImageCount, "uint32_t", "minImageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageCount, "uint32_t", "maxImageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.currentExtent, "VkExtent2D", "currentExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minImageExtent, "VkExtent2D", "minImageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxImageExtent, "VkExtent2D", "maxImageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageArrayLayers, "uint32_t", "maxImageArrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagsKHR(api_dump, object.supportedTransforms, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.currentTransform, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompositeAlphaFlagsKHR(api_dump, object.supportedCompositeAlpha, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.supportedUsageFlags, "VkImageUsageFlags", "supportedUsageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceFormatKHR(ApiDumpInstance& api_dump, const VkSurfaceFormatKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkColorSpaceKHR(api_dump, object.colorSpace, "VkColorSpaceKHR", "colorSpace", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainCreateInfoKHR(ApiDumpInstance& api_dump, const VkSwapchainCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainCreateFlagsKHR(api_dump, object.flags, "VkSwapchainCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceKHR(api_dump, object.surface, "VkSurfaceKHR", "surface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minImageCount, "uint32_t", "minImageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.imageFormat, "VkFormat", "imageFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkColorSpaceKHR(api_dump, object.imageColorSpace, "VkColorSpaceKHR", "imageColorSpace", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.imageExtent, "VkExtent2D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageArrayLayers, "uint32_t", "imageArrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.imageUsage, "VkImageUsageFlags", "imageUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSharingMode(api_dump, object.imageSharingMode, "VkSharingMode", "imageSharingMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndexCount, "uint32_t", "queueFamilyIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
     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>);
+        dump_pointer_array(api_dump, object.pQueueFamilyIndices, object.queueFamilyIndexCount, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<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 (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {
+            dump_special(api_dump, "UNUSED", "const uint32_t*", "pQueueFamilyIndices", indents + 1);
+        } else if (api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_json_UNUSED(api_dump, "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);
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.preTransform, "VkSurfaceTransformFlagBitsKHR", "preTransform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompositeAlphaFlagBitsKHR(api_dump, object.compositeAlpha, "VkCompositeAlphaFlagBitsKHR", "compositeAlpha", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentModeKHR(api_dump, object.presentMode, "VkPresentModeKHR", "presentMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.clipped, "VkBool32", "clipped", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.oldSwapchain, "VkSwapchainKHR", "oldSwapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentInfoKHR(ApiDumpInstance& api_dump, const VkPresentInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreCount, "uint32_t", "waitSemaphoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphores, object.waitSemaphoreCount, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSwapchains, object.swapchainCount, "const VkSwapchainKHR*", "pSwapchains", "const VkSwapchainKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSwapchainKHR);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImageIndices, object.swapchainCount, "const uint32_t*", "pImageIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pResults, object.swapchainCount, "VkResult*", "pResults", "VkResult", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkResult);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageSwapchainCreateInfoKHR(ApiDumpInstance& api_dump, const VkImageSwapchainCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.swapchain, "VkSwapchainKHR", "swapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindImageMemorySwapchainInfoKHR(ApiDumpInstance& api_dump, const VkBindImageMemorySwapchainInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.swapchain, "VkSwapchainKHR", "swapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageIndex, "uint32_t", "imageIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAcquireNextImageInfoKHR(ApiDumpInstance& api_dump, const VkAcquireNextImageInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.swapchain, "VkSwapchainKHR", "swapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeout, "uint64_t", "timeout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFence(api_dump, object.fence, "VkFence", "fence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceMask, "uint32_t", "deviceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance& api_dump, const VkDeviceGroupPresentCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.presentMask, VK_MAX_DEVICE_GROUP_SIZE, "uint32_t[VK_MAX_DEVICE_GROUP_SIZE]", "presentMask", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_VkDeviceGroupPresentModeFlagsKHR(api_dump, object.modes, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupPresentInfoKHR(ApiDumpInstance& api_dump, const VkDeviceGroupPresentInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDeviceMasks, object.swapchainCount, "const uint32_t*", "pDeviceMasks", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_VkDeviceGroupPresentModeFlagBitsKHR(api_dump, object.mode, "VkDeviceGroupPresentModeFlagBitsKHR", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceGroupSwapchainCreateInfoKHR(ApiDumpInstance& api_dump, const VkDeviceGroupSwapchainCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceGroupPresentModeFlagsKHR(api_dump, object.modes, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayModeParametersKHR(ApiDumpInstance& api_dump, const VkDisplayModeParametersKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkExtent2D(api_dump, object.visibleRegion, "VkExtent2D", "visibleRegion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.refreshRate, "uint32_t", "refreshRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayModeCreateInfoKHR(ApiDumpInstance& api_dump, const VkDisplayModeCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayModeCreateFlagsKHR(api_dump, object.flags, "VkDisplayModeCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayModeParametersKHR(api_dump, object.parameters, "VkDisplayModeParametersKHR", "parameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayModePropertiesKHR(ApiDumpInstance& api_dump, const VkDisplayModePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkDisplayModeKHR(api_dump, object.displayMode, "VkDisplayModeKHR", "displayMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayModeParametersKHR(api_dump, object.parameters, "VkDisplayModeParametersKHR", "parameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPlaneCapabilitiesKHR(ApiDumpInstance& api_dump, const VkDisplayPlaneCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkDisplayPlaneAlphaFlagsKHR(api_dump, object.supportedAlpha, "VkDisplayPlaneAlphaFlagsKHR", "supportedAlpha", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.minSrcPosition, "VkOffset2D", "minSrcPosition", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.maxSrcPosition, "VkOffset2D", "maxSrcPosition", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minSrcExtent, "VkExtent2D", "minSrcExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxSrcExtent, "VkExtent2D", "maxSrcExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.minDstPosition, "VkOffset2D", "minDstPosition", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.maxDstPosition, "VkOffset2D", "maxDstPosition", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minDstExtent, "VkExtent2D", "minDstExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxDstExtent, "VkExtent2D", "maxDstExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPlanePropertiesKHR(ApiDumpInstance& api_dump, const VkDisplayPlanePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkDisplayKHR(api_dump, object.currentDisplay, "VkDisplayKHR", "currentDisplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.currentStackIndex, "uint32_t", "currentStackIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPropertiesKHR(ApiDumpInstance& api_dump, const VkDisplayPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkDisplayKHR(api_dump, object.display, "VkDisplayKHR", "display", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.displayName, "const char*", "displayName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.physicalDimensions, "VkExtent2D", "physicalDimensions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.physicalResolution, "VkExtent2D", "physicalResolution", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagsKHR(api_dump, object.supportedTransforms, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.planeReorderPossible, "VkBool32", "planeReorderPossible", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.persistentContent, "VkBool32", "persistentContent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplaySurfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkDisplaySurfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplaySurfaceCreateFlagsKHR(api_dump, object.flags, "VkDisplaySurfaceCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayModeKHR(api_dump, object.displayMode, "VkDisplayModeKHR", "displayMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.planeIndex, "uint32_t", "planeIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.planeStackIndex, "uint32_t", "planeStackIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.transform, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.globalAlpha, "float", "globalAlpha", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayPlaneAlphaFlagBitsKHR(api_dump, object.alphaMode, "VkDisplayPlaneAlphaFlagBitsKHR", "alphaMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.imageExtent, "VkExtent2D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPresentInfoKHR(ApiDumpInstance& api_dump, const VkDisplayPresentInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRect2D(api_dump, object.srcRect, "VkRect2D", "srcRect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRect2D(api_dump, object.dstRect, "VkRect2D", "dstRect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.persistent, "VkBool32", "persistent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkXlibSurfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkXlibSurfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkXlibSurfaceCreateFlagsKHR(api_dump, object.flags, "VkXlibSurfaceCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<Display*>(api_dump, object.dpy, "Display*", "dpy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<Window>(api_dump, object.window, "Window", "window", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkXcbSurfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkXcbSurfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkXcbSurfaceCreateFlagsKHR(api_dump, object.flags, "VkXcbSurfaceCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<xcb_connection_t*>(api_dump, object.connection, "xcb_connection_t*", "connection", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_uint64_t_as_pointer(api_dump, object.window, "xcb_window_t", "window", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkWaylandSurfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkWaylandSurfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkWaylandSurfaceCreateFlagsKHR(api_dump, object.flags, "VkWaylandSurfaceCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct wl_display*>(api_dump, object.display, "struct wl_display*", "display", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct wl_surface*>(api_dump, object.surface, "struct wl_surface*", "surface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkAndroidSurfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkAndroidSurfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAndroidSurfaceCreateFlagsKHR(api_dump, object.flags, "VkAndroidSurfaceCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct ANativeWindow*>(api_dump, object.window, "struct ANativeWindow*", "window", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkWin32SurfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkWin32SurfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkWin32SurfaceCreateFlagsKHR(api_dump, object.flags, "VkWin32SurfaceCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HINSTANCE>(api_dump, object.hinstance, "HINSTANCE", "hinstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HWND>(api_dump, object.hwnd, "HWND", "hwnd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkQueueFamilyQueryResultStatusPropertiesKHR(ApiDumpInstance& api_dump, const VkQueueFamilyQueryResultStatusPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.queryResultStatusSupport, "VkBool32", "queryResultStatusSupport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyVideoPropertiesKHR(ApiDumpInstance& api_dump, const VkQueueFamilyVideoPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoCodecOperationFlagsKHR(api_dump, object.videoCodecOperations, "VkVideoCodecOperationFlagsKHR", "videoCodecOperations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoCodecOperationFlagBitsKHR(api_dump, object.videoCodecOperation, "VkVideoCodecOperationFlagBitsKHR", "videoCodecOperation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoChromaSubsamplingFlagsKHR(api_dump, object.chromaSubsampling, "VkVideoChromaSubsamplingFlagsKHR", "chromaSubsampling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoComponentBitDepthFlagsKHR(api_dump, object.lumaBitDepth, "VkVideoComponentBitDepthFlagsKHR", "lumaBitDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoComponentBitDepthFlagsKHR(api_dump, object.chromaBitDepth, "VkVideoComponentBitDepthFlagsKHR", "chromaBitDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoProfileListInfoKHR(ApiDumpInstance& api_dump, const VkVideoProfileListInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.profileCount, "uint32_t", "profileCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pProfiles, object.profileCount, "const VkVideoProfileInfoKHR*", "pProfiles", "const VkVideoProfileInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoCapabilityFlagsKHR(api_dump, object.flags, "VkVideoCapabilityFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minBitstreamBufferOffsetAlignment, "VkDeviceSize", "minBitstreamBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minBitstreamBufferSizeAlignment, "VkDeviceSize", "minBitstreamBufferSizeAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.pictureAccessGranularity, "VkExtent2D", "pictureAccessGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minCodedExtent, "VkExtent2D", "minCodedExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxCodedExtent, "VkExtent2D", "maxCodedExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDpbSlots, "uint32_t", "maxDpbSlots", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxActiveReferencePictures, "uint32_t", "maxActiveReferencePictures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtensionProperties(api_dump, object.stdHeaderVersion, "VkExtensionProperties", "stdHeaderVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoFormatInfoKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoFormatInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.imageUsage, "VkImageUsageFlags", "imageUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoFormatPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoFormatPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.componentMapping, "VkComponentMapping", "componentMapping", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCreateFlags(api_dump, object.imageCreateFlags, "VkImageCreateFlags", "imageCreateFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageType(api_dump, object.imageType, "VkImageType", "imageType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageTiling(api_dump, object.imageTiling, "VkImageTiling", "imageTiling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.imageUsageFlags, "VkImageUsageFlags", "imageUsageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoPictureResourceInfoKHR(ApiDumpInstance& api_dump, const VkVideoPictureResourceInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.codedOffset, "VkOffset2D", "codedOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.codedExtent, "VkExtent2D", "codedExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseArrayLayer, "uint32_t", "baseArrayLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageViewBinding, "VkImageView", "imageViewBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoReferenceSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoReferenceSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.slotIndex, "int32_t", "slotIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pPictureResource, "const VkVideoPictureResourceInfoKHR*", "pPictureResource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoPictureResourceInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoSessionMemoryRequirementsKHR(ApiDumpInstance& api_dump, const VkVideoSessionMemoryRequirementsKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryBindIndex, "uint32_t", "memoryBindIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryRequirements(api_dump, object.memoryRequirements, "VkMemoryRequirements", "memoryRequirements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindVideoSessionMemoryInfoKHR(ApiDumpInstance& api_dump, const VkBindVideoSessionMemoryInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryBindIndex, "uint32_t", "memoryBindIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memorySize, "VkDeviceSize", "memorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoSessionCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoSessionCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndex, "uint32_t", "queueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionCreateFlagsKHR(api_dump, object.flags, "VkVideoSessionCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pVideoProfile, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR);
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.pictureFormat, "VkFormat", "pictureFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxCodedExtent, "VkExtent2D", "maxCodedExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.referencePictureFormat, "VkFormat", "referencePictureFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDpbSlots, "uint32_t", "maxDpbSlots", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxActiveReferencePictures, "uint32_t", "maxActiveReferencePictures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdHeaderVersion, "const VkExtensionProperties*", "pStdHeaderVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkExtensionProperties);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoSessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoSessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionParametersCreateFlagsKHR(api_dump, object.flags, "VkVideoSessionParametersCreateFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionParametersKHR(api_dump, object.videoSessionParametersTemplate, "VkVideoSessionParametersKHR", "videoSessionParametersTemplate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionKHR(api_dump, object.videoSession, "VkVideoSessionKHR", "videoSession", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoSessionParametersUpdateInfoKHR(ApiDumpInstance& api_dump, const VkVideoSessionParametersUpdateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.updateSequenceCount, "uint32_t", "updateSequenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoBeginCodingInfoKHR(ApiDumpInstance& api_dump, const VkVideoBeginCodingInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoBeginCodingFlagsKHR(api_dump, object.flags, "VkVideoBeginCodingFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionKHR(api_dump, object.videoSession, "VkVideoSessionKHR", "videoSession", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionParametersKHR(api_dump, object.videoSessionParameters, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.referenceSlotCount, "uint32_t", "referenceSlotCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReferenceSlots, object.referenceSlotCount, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEndCodingInfoKHR(ApiDumpInstance& api_dump, const VkVideoEndCodingInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEndCodingFlagsKHR(api_dump, object.flags, "VkVideoEndCodingFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoCodingControlInfoKHR(ApiDumpInstance& api_dump, const VkVideoCodingControlInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoCodingControlFlagsKHR(api_dump, object.flags, "VkVideoCodingControlFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoDecodeCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoDecodeCapabilityFlagsKHR(api_dump, object.flags, "VkVideoDecodeCapabilityFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeUsageInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeUsageInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoDecodeUsageFlagsKHR(api_dump, object.videoUsageHints, "VkVideoDecodeUsageFlagsKHR", "videoUsageHints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoDecodeFlagsKHR(api_dump, object.flags, "VkVideoDecodeFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.srcBuffer, "VkBuffer", "srcBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.srcBufferOffset, "VkDeviceSize", "srcBufferOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.srcBufferRange, "VkDeviceSize", "srcBufferRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoPictureResourceInfoKHR(api_dump, object.dstPictureResource, "VkVideoPictureResourceInfoKHR", "dstPictureResource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSetupReferenceSlot, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.referenceSlotCount, "uint32_t", "referenceSlotCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReferenceSlots, object.referenceSlotCount, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264CapabilityFlagsKHR(api_dump, object.flags, "VkVideoEncodeH264CapabilityFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264LevelIdc(api_dump, object.maxLevelIdc, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSliceCount, "uint32_t", "maxSliceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPPictureL0ReferenceCount, "uint32_t", "maxPPictureL0ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBPictureL0ReferenceCount, "uint32_t", "maxBPictureL0ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxL1ReferenceCount, "uint32_t", "maxL1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTemporalLayerCount, "uint32_t", "maxTemporalLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.expectDyadicTemporalLayerPattern, "VkBool32", "expectDyadicTemporalLayerPattern", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minQp, "int32_t", "minQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.maxQp, "int32_t", "maxQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersGopRemainingFrames, "VkBool32", "prefersGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.requiresGopRemainingFrames, "VkBool32", "requiresGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264StdFlagsKHR(api_dump, object.stdSyntaxFlags, "VkVideoEncodeH264StdFlagsKHR", "stdSyntaxFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264QpKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264QpKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<int32_t>(api_dump, object.qpI, "int32_t", "qpI", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.qpP, "int32_t", "qpP", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.qpB, "int32_t", "qpB", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264QualityLevelPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264QualityLevelPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264RateControlFlagsKHR(api_dump, object.preferredRateControlFlags, "VkVideoEncodeH264RateControlFlagsKHR", "preferredRateControlFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredGopFrameCount, "uint32_t", "preferredGopFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredIdrPeriod, "uint32_t", "preferredIdrPeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredConsecutiveBFrameCount, "uint32_t", "preferredConsecutiveBFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredTemporalLayerCount, "uint32_t", "preferredTemporalLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264QpKHR(api_dump, object.preferredConstantQp, "VkVideoEncodeH264QpKHR", "preferredConstantQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxL0ReferenceCount, "uint32_t", "preferredMaxL0ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxL1ReferenceCount, "uint32_t", "preferredMaxL1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.preferredStdEntropyCodingModeFlag, "VkBool32", "preferredStdEntropyCodingModeFlag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264SessionCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264SessionCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxLevelIdc, "VkBool32", "useMaxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264LevelIdc(api_dump, object.maxLevelIdc, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264SessionParametersAddInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264SessionParametersAddInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdSPSCount, "uint32_t", "stdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdSPSs, object.stdSPSCount, "const StdVideoH264SequenceParameterSet*", "pStdSPSs", "const StdVideoH264SequenceParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdPPSCount, "uint32_t", "stdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdPPSs, object.stdPPSCount, "const StdVideoH264PictureParameterSet*", "pStdPPSs", "const StdVideoH264PictureParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264SessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264SessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdSPSCount, "uint32_t", "maxStdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdPPSCount, "uint32_t", "maxStdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pParametersAddInfo, "const VkVideoEncodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH264SessionParametersAddInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264SessionParametersGetInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264SessionParametersGetInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.writeStdSPS, "VkBool32", "writeStdSPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.writeStdPPS, "VkBool32", "writeStdPPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdSPSId, "uint32_t", "stdSPSId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdPPSId, "uint32_t", "stdPPSId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasStdSPSOverrides, "VkBool32", "hasStdSPSOverrides", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasStdPPSOverrides, "VkBool32", "hasStdPPSOverrides", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264NaluSliceInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264NaluSliceInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.constantQp, "int32_t", "constantQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSliceHeader, "const StdVideoEncodeH264SliceHeader*", "pStdSliceHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264SliceHeader);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.naluSliceEntryCount, "uint32_t", "naluSliceEntryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pNaluSliceEntries, object.naluSliceEntryCount, "const VkVideoEncodeH264NaluSliceInfoKHR*", "pNaluSliceEntries", "const VkVideoEncodeH264NaluSliceInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH264NaluSliceInfoKHR);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoEncodeH264PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264PictureInfo);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.generatePrefixNalu, "VkBool32", "generatePrefixNalu", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264DpbSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264DpbSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdReferenceInfo, "const StdVideoEncodeH264ReferenceInfo*", "pStdReferenceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264ReferenceInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264ProfileIdc(api_dump, object.stdProfileIdc, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264RateControlInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264RateControlInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264RateControlFlagsKHR(api_dump, object.flags, "VkVideoEncodeH264RateControlFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopFrameCount, "uint32_t", "gopFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.idrPeriod, "uint32_t", "idrPeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.consecutiveBFrameCount, "uint32_t", "consecutiveBFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.temporalLayerCount, "uint32_t", "temporalLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264FrameSizeKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264FrameSizeKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.frameISize, "uint32_t", "frameISize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.framePSize, "uint32_t", "framePSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frameBSize, "uint32_t", "frameBSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264RateControlLayerInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264RateControlLayerInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMinQp, "VkBool32", "useMinQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264QpKHR(api_dump, object.minQp, "VkVideoEncodeH264QpKHR", "minQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxQp, "VkBool32", "useMaxQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264QpKHR(api_dump, object.maxQp, "VkVideoEncodeH264QpKHR", "maxQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxFrameSize, "VkBool32", "useMaxFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH264FrameSizeKHR(api_dump, object.maxFrameSize, "VkVideoEncodeH264FrameSizeKHR", "maxFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264GopRemainingFrameInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264GopRemainingFrameInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useGopRemainingFrames, "VkBool32", "useGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingI, "uint32_t", "gopRemainingI", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingP, "uint32_t", "gopRemainingP", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingB, "uint32_t", "gopRemainingB", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265CapabilityFlagsKHR(api_dump, object.flags, "VkVideoEncodeH265CapabilityFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265LevelIdc(api_dump, object.maxLevelIdc, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSliceSegmentCount, "uint32_t", "maxSliceSegmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxTiles, "VkExtent2D", "maxTiles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265CtbSizeFlagsKHR(api_dump, object.ctbSizes, "VkVideoEncodeH265CtbSizeFlagsKHR", "ctbSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265TransformBlockSizeFlagsKHR(api_dump, object.transformBlockSizes, "VkVideoEncodeH265TransformBlockSizeFlagsKHR", "transformBlockSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPPictureL0ReferenceCount, "uint32_t", "maxPPictureL0ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBPictureL0ReferenceCount, "uint32_t", "maxBPictureL0ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxL1ReferenceCount, "uint32_t", "maxL1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSubLayerCount, "uint32_t", "maxSubLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.expectDyadicTemporalSubLayerPattern, "VkBool32", "expectDyadicTemporalSubLayerPattern", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minQp, "int32_t", "minQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.maxQp, "int32_t", "maxQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersGopRemainingFrames, "VkBool32", "prefersGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.requiresGopRemainingFrames, "VkBool32", "requiresGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265StdFlagsKHR(api_dump, object.stdSyntaxFlags, "VkVideoEncodeH265StdFlagsKHR", "stdSyntaxFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265SessionCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265SessionCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxLevelIdc, "VkBool32", "useMaxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265LevelIdc(api_dump, object.maxLevelIdc, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265QpKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265QpKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<int32_t>(api_dump, object.qpI, "int32_t", "qpI", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.qpP, "int32_t", "qpP", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.qpB, "int32_t", "qpB", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265QualityLevelPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265QualityLevelPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265RateControlFlagsKHR(api_dump, object.preferredRateControlFlags, "VkVideoEncodeH265RateControlFlagsKHR", "preferredRateControlFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredGopFrameCount, "uint32_t", "preferredGopFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredIdrPeriod, "uint32_t", "preferredIdrPeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredConsecutiveBFrameCount, "uint32_t", "preferredConsecutiveBFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredSubLayerCount, "uint32_t", "preferredSubLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265QpKHR(api_dump, object.preferredConstantQp, "VkVideoEncodeH265QpKHR", "preferredConstantQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxL0ReferenceCount, "uint32_t", "preferredMaxL0ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxL1ReferenceCount, "uint32_t", "preferredMaxL1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265SessionParametersAddInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265SessionParametersAddInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdVPSCount, "uint32_t", "stdVPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdVPSs, object.stdVPSCount, "const StdVideoH265VideoParameterSet*", "pStdVPSs", "const StdVideoH265VideoParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdSPSCount, "uint32_t", "stdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdSPSs, object.stdSPSCount, "const StdVideoH265SequenceParameterSet*", "pStdSPSs", "const StdVideoH265SequenceParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdPPSCount, "uint32_t", "stdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdPPSs, object.stdPPSCount, "const StdVideoH265PictureParameterSet*", "pStdPPSs", "const StdVideoH265PictureParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265SessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265SessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdVPSCount, "uint32_t", "maxStdVPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdSPSCount, "uint32_t", "maxStdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdPPSCount, "uint32_t", "maxStdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pParametersAddInfo, "const VkVideoEncodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH265SessionParametersAddInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265SessionParametersGetInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265SessionParametersGetInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.writeStdVPS, "VkBool32", "writeStdVPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.writeStdSPS, "VkBool32", "writeStdSPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.writeStdPPS, "VkBool32", "writeStdPPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdVPSId, "uint32_t", "stdVPSId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdSPSId, "uint32_t", "stdSPSId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdPPSId, "uint32_t", "stdPPSId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasStdVPSOverrides, "VkBool32", "hasStdVPSOverrides", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasStdSPSOverrides, "VkBool32", "hasStdSPSOverrides", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasStdPPSOverrides, "VkBool32", "hasStdPPSOverrides", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265NaluSliceSegmentInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.constantQp, "int32_t", "constantQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSliceSegmentHeader, "const StdVideoEncodeH265SliceSegmentHeader*", "pStdSliceSegmentHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265SliceSegmentHeader);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.naluSliceSegmentEntryCount, "uint32_t", "naluSliceSegmentEntryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pNaluSliceSegmentEntries, object.naluSliceSegmentEntryCount, "const VkVideoEncodeH265NaluSliceSegmentInfoKHR*", "pNaluSliceSegmentEntries", "const VkVideoEncodeH265NaluSliceSegmentInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoEncodeH265PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265PictureInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265DpbSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265DpbSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdReferenceInfo, "const StdVideoEncodeH265ReferenceInfo*", "pStdReferenceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265ReferenceInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265ProfileIdc(api_dump, object.stdProfileIdc, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265RateControlInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265RateControlInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265RateControlFlagsKHR(api_dump, object.flags, "VkVideoEncodeH265RateControlFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopFrameCount, "uint32_t", "gopFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.idrPeriod, "uint32_t", "idrPeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.consecutiveBFrameCount, "uint32_t", "consecutiveBFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subLayerCount, "uint32_t", "subLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265FrameSizeKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265FrameSizeKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.frameISize, "uint32_t", "frameISize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.framePSize, "uint32_t", "framePSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frameBSize, "uint32_t", "frameBSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265RateControlLayerInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265RateControlLayerInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMinQp, "VkBool32", "useMinQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265QpKHR(api_dump, object.minQp, "VkVideoEncodeH265QpKHR", "minQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxQp, "VkBool32", "useMaxQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265QpKHR(api_dump, object.maxQp, "VkVideoEncodeH265QpKHR", "maxQp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxFrameSize, "VkBool32", "useMaxFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265FrameSizeKHR(api_dump, object.maxFrameSize, "VkVideoEncodeH265FrameSizeKHR", "maxFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265GopRemainingFrameInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265GopRemainingFrameInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useGopRemainingFrames, "VkBool32", "useGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingI, "uint32_t", "gopRemainingI", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingP, "uint32_t", "gopRemainingP", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingB, "uint32_t", "gopRemainingB", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264ProfileIdc(api_dump, object.stdProfileIdc, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(api_dump, object.pictureLayout, "VkVideoDecodeH264PictureLayoutFlagBitsKHR", "pictureLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH264LevelIdc(api_dump, object.maxLevelIdc, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.fieldOffsetGranularity, "VkOffset2D", "fieldOffsetGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264SessionParametersAddInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264SessionParametersAddInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdSPSCount, "uint32_t", "stdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdSPSs, object.stdSPSCount, "const StdVideoH264SequenceParameterSet*", "pStdSPSs", "const StdVideoH264SequenceParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdPPSCount, "uint32_t", "stdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdPPSs, object.stdPPSCount, "const StdVideoH264PictureParameterSet*", "pStdPPSs", "const StdVideoH264PictureParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264SessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264SessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdSPSCount, "uint32_t", "maxStdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdPPSCount, "uint32_t", "maxStdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pParametersAddInfo, "const VkVideoDecodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoDecodeH264SessionParametersAddInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoDecodeH264PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH264PictureInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sliceCount, "uint32_t", "sliceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSliceOffsets, object.sliceCount, "const uint32_t*", "pSliceOffsets", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264DpbSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264DpbSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdReferenceInfo, "const StdVideoDecodeH264ReferenceInfo*", "pStdReferenceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH264ReferenceInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportMemoryWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkImportMemoryWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HANDLE>(api_dump, object.handle, "HANDLE", "handle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<LPCWSTR>(api_dump, object.name, "LPCWSTR", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMemoryWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkExportMemoryWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const SECURITY_ATTRIBUTES*>(api_dump, object.pAttributes, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<DWORD>(api_dump, object.dwAccess, "DWORD", "dwAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<LPCWSTR>(api_dump, object.name, "LPCWSTR", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryWin32HandlePropertiesKHR(ApiDumpInstance& api_dump, const VkMemoryWin32HandlePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkMemoryGetWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportMemoryFdInfoKHR(ApiDumpInstance& api_dump, const VkImportMemoryFdInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int>(api_dump, object.fd, "int", "fd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryFdPropertiesKHR(ApiDumpInstance& api_dump, const VkMemoryFdPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetFdInfoKHR(ApiDumpInstance& api_dump, const VkMemoryGetFdInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkWin32KeyedMutexAcquireReleaseInfoKHR(ApiDumpInstance& api_dump, const VkWin32KeyedMutexAcquireReleaseInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.acquireCount, "uint32_t", "acquireCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAcquireSyncs, object.acquireCount, "const VkDeviceMemory*", "pAcquireSyncs", "const VkDeviceMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAcquireKeys, object.acquireCount, "const uint64_t*", "pAcquireKeys", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAcquireTimeouts, object.acquireCount, "const uint32_t*", "pAcquireTimeouts", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.releaseCount, "uint32_t", "releaseCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReleaseSyncs, object.releaseCount, "const VkDeviceMemory*", "pReleaseSyncs", "const VkDeviceMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReleaseKeys, object.releaseCount, "const uint64_t*", "pReleaseKeys", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportSemaphoreWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkImportSemaphoreWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphoreImportFlags(api_dump, object.flags, "VkSemaphoreImportFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HANDLE>(api_dump, object.handle, "HANDLE", "handle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<LPCWSTR>(api_dump, object.name, "LPCWSTR", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportSemaphoreWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkExportSemaphoreWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const SECURITY_ATTRIBUTES*>(api_dump, object.pAttributes, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<DWORD>(api_dump, object.dwAccess, "DWORD", "dwAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<LPCWSTR>(api_dump, object.name, "LPCWSTR", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkD3D12FenceSubmitInfoKHR(ApiDumpInstance& api_dump, const VkD3D12FenceSubmitInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.waitSemaphoreValuesCount, "uint32_t", "waitSemaphoreValuesCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pWaitSemaphoreValues, object.waitSemaphoreValuesCount, "const uint64_t*", "pWaitSemaphoreValues", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.signalSemaphoreValuesCount, "uint32_t", "signalSemaphoreValuesCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSignalSemaphoreValues, object.signalSemaphoreValuesCount, "const uint64_t*", "pSignalSemaphoreValues", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreGetWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkSemaphoreGetWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportSemaphoreFdInfoKHR(ApiDumpInstance& api_dump, const VkImportSemaphoreFdInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphoreImportFlags(api_dump, object.flags, "VkSemaphoreImportFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int>(api_dump, object.fd, "int", "fd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreGetFdInfoKHR(ApiDumpInstance& api_dump, const VkSemaphoreGetFdInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRectLayerKHR(ApiDumpInstance& api_dump, const VkRectLayerKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkOffset2D(api_dump, object.offset, "VkOffset2D", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.extent, "VkExtent2D", "extent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layer, "uint32_t", "layer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentRegionKHR(ApiDumpInstance& api_dump, const VkPresentRegionKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.rectangleCount, "uint32_t", "rectangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRectangles, object.rectangleCount, "const VkRectLayerKHR*", "pRectangles", "const VkRectLayerKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRectLayerKHR);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentRegionsKHR(ApiDumpInstance& api_dump, const VkPresentRegionsKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.swapchainCount, "const VkPresentRegionKHR*", "pRegions", "const VkPresentRegionKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentRegionKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSharedPresentSurfaceCapabilitiesKHR(ApiDumpInstance& api_dump, const VkSharedPresentSurfaceCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.sharedPresentSupportedUsageFlags, "VkImageUsageFlags", "sharedPresentSupportedUsageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportFenceWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkImportFenceWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFence(api_dump, object.fence, "VkFence", "fence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFenceImportFlags(api_dump, object.flags, "VkFenceImportFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlagBits(api_dump, object.handleType, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HANDLE>(api_dump, object.handle, "HANDLE", "handle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<LPCWSTR>(api_dump, object.name, "LPCWSTR", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportFenceWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkExportFenceWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const SECURITY_ATTRIBUTES*>(api_dump, object.pAttributes, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<DWORD>(api_dump, object.dwAccess, "DWORD", "dwAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<LPCWSTR>(api_dump, object.name, "LPCWSTR", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFenceGetWin32HandleInfoKHR(ApiDumpInstance& api_dump, const VkFenceGetWin32HandleInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFence(api_dump, object.fence, "VkFence", "fence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlagBits(api_dump, object.handleType, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportFenceFdInfoKHR(ApiDumpInstance& api_dump, const VkImportFenceFdInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFence(api_dump, object.fence, "VkFence", "fence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFenceImportFlags(api_dump, object.flags, "VkFenceImportFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlagBits(api_dump, object.handleType, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int>(api_dump, object.fd, "int", "fd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFenceGetFdInfoKHR(ApiDumpInstance& api_dump, const VkFenceGetFdInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFence(api_dump, object.fence, "VkFence", "fence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalFenceHandleTypeFlagBits(api_dump, object.handleType, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePerformanceQueryFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePerformanceQueryFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.performanceCounterQueryPools, "VkBool32", "performanceCounterQueryPools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.performanceCounterMultipleQueryPools, "VkBool32", "performanceCounterMultipleQueryPools", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePerformanceQueryPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePerformanceQueryPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.allowCommandBufferQueryCopies, "VkBool32", "allowCommandBufferQueryCopies", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceCounterKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceCounterUnitKHR(api_dump, object.unit, "VkPerformanceCounterUnitKHR", "unit", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceCounterScopeKHR(api_dump, object.scope, "VkPerformanceCounterScopeKHR", "scope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceCounterStorageKHR(api_dump, object.storage, "VkPerformanceCounterStorageKHR", "storage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.uuid, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "uuid", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceCounterDescriptionKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterDescriptionKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceCounterDescriptionFlagsKHR(api_dump, object.flags, "VkPerformanceCounterDescriptionFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.category, "char[VK_MAX_DESCRIPTION_SIZE]", "category", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueryPoolPerformanceCreateInfoKHR(ApiDumpInstance& api_dump, const VkQueryPoolPerformanceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndex, "uint32_t", "queueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.counterIndexCount, "uint32_t", "counterIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCounterIndices, object.counterIndexCount, "const uint32_t*", "pCounterIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceCounterResultKHR(ApiDumpInstance& api_dump, const VkPerformanceCounterResultKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_type<int32_t>(api_dump, object.int32, "int32_t", "int32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.int64, "int64_t", "int64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.uint32, "uint32_t", "uint32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.uint64, "uint64_t", "uint64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.float32, "float", "float32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<double>(api_dump, object.float64, "double", "float64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAcquireProfilingLockInfoKHR(ApiDumpInstance& api_dump, const VkAcquireProfilingLockInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAcquireProfilingLockFlagsKHR(api_dump, object.flags, "VkAcquireProfilingLockFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeout, "uint64_t", "timeout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceQuerySubmitInfoKHR(ApiDumpInstance& api_dump, const VkPerformanceQuerySubmitInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.counterPassIndex, "uint32_t", "counterPassIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSurfaceInfo2KHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceSurfaceInfo2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceKHR(api_dump, object.surface, "VkSurfaceKHR", "surface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilities2KHR(ApiDumpInstance& api_dump, const VkSurfaceCapabilities2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceCapabilitiesKHR(api_dump, object.surfaceCapabilities, "VkSurfaceCapabilitiesKHR", "surfaceCapabilities", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceFormat2KHR(ApiDumpInstance& api_dump, const VkSurfaceFormat2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceFormatKHR(api_dump, object.surfaceFormat, "VkSurfaceFormatKHR", "surfaceFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayProperties2KHR(ApiDumpInstance& api_dump, const VkDisplayProperties2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayPropertiesKHR(api_dump, object.displayProperties, "VkDisplayPropertiesKHR", "displayProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPlaneProperties2KHR(ApiDumpInstance& api_dump, const VkDisplayPlaneProperties2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayPlanePropertiesKHR(api_dump, object.displayPlaneProperties, "VkDisplayPlanePropertiesKHR", "displayPlaneProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayModeProperties2KHR(ApiDumpInstance& api_dump, const VkDisplayModeProperties2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayModePropertiesKHR(api_dump, object.displayModeProperties, "VkDisplayModePropertiesKHR", "displayModeProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPlaneInfo2KHR(ApiDumpInstance& api_dump, const VkDisplayPlaneInfo2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayModeKHR(api_dump, object.mode, "VkDisplayModeKHR", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.planeIndex, "uint32_t", "planeIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPlaneCapabilities2KHR(ApiDumpInstance& api_dump, const VkDisplayPlaneCapabilities2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayPlaneCapabilitiesKHR(api_dump, object.capabilities, "VkDisplayPlaneCapabilitiesKHR", "capabilities", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderBfloat16FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderBfloat16FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBFloat16Type, "VkBool32", "shaderBFloat16Type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBFloat16DotProduct, "VkBool32", "shaderBFloat16DotProduct", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBFloat16CooperativeMatrix, "VkBool32", "shaderBFloat16CooperativeMatrix", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDevicePortabilitySubsetFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePortabilitySubsetFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.constantAlphaColorBlendFactors, "VkBool32", "constantAlphaColorBlendFactors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.events, "VkBool32", "events", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageViewFormatReinterpretation, "VkBool32", "imageViewFormatReinterpretation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageViewFormatSwizzle, "VkBool32", "imageViewFormatSwizzle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageView2DOn3DImage, "VkBool32", "imageView2DOn3DImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multisampleArrayImage, "VkBool32", "multisampleArrayImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.mutableComparisonSamplers, "VkBool32", "mutableComparisonSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pointPolygons, "VkBool32", "pointPolygons", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.samplerMipLodBias, "VkBool32", "samplerMipLodBias", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.separateStencilMaskRef, "VkBool32", "separateStencilMaskRef", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSampleRateInterpolationFunctions, "VkBool32", "shaderSampleRateInterpolationFunctions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tessellationIsolines, "VkBool32", "tessellationIsolines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tessellationPointMode, "VkBool32", "tessellationPointMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.triangleFans, "VkBool32", "triangleFans", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexAttributeAccessBeyondStride, "VkBool32", "vertexAttributeAccessBeyondStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePortabilitySubsetPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePortabilitySubsetPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minVertexInputBindingStrideAlignment, "uint32_t", "minVertexInputBindingStrideAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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_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_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_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_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_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_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_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_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);
+void dump_VkPhysicalDeviceShaderClockFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderClockFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupClock, "VkBool32", "shaderSubgroupClock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderDeviceClock, "VkBool32", "shaderDeviceClock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265ProfileIdc(api_dump, object.stdProfileIdc, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoH265LevelIdc(api_dump, object.maxLevelIdc, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265SessionParametersAddInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265SessionParametersAddInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdVPSCount, "uint32_t", "stdVPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdVPSs, object.stdVPSCount, "const StdVideoH265VideoParameterSet*", "pStdVPSs", "const StdVideoH265VideoParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdSPSCount, "uint32_t", "stdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdSPSs, object.stdSPSCount, "const StdVideoH265SequenceParameterSet*", "pStdSPSs", "const StdVideoH265SequenceParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdPPSCount, "uint32_t", "stdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdPPSs, object.stdPPSCount, "const StdVideoH265PictureParameterSet*", "pStdPPSs", "const StdVideoH265PictureParameterSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265SessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265SessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdVPSCount, "uint32_t", "maxStdVPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdSPSCount, "uint32_t", "maxStdSPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxStdPPSCount, "uint32_t", "maxStdPPSCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pParametersAddInfo, "const VkVideoDecodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoDecodeH265SessionParametersAddInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoDecodeH265PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH265PictureInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sliceSegmentCount, "uint32_t", "sliceSegmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSliceSegmentOffsets, object.sliceSegmentCount, "const uint32_t*", "pSliceSegmentOffsets", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265DpbSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265DpbSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdReferenceInfo, "const StdVideoDecodeH265ReferenceInfo*", "pStdReferenceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH265ReferenceInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFragmentShadingRateAttachmentInfoKHR(ApiDumpInstance& api_dump, const VkFragmentShadingRateAttachmentInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pFragmentShadingRateAttachment, "const VkAttachmentReference2*", "pFragmentShadingRateAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2);
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.shadingRateAttachmentTexelSize, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineFragmentShadingRateStateCreateInfoKHR(ApiDumpInstance& api_dump, const VkPipelineFragmentShadingRateStateCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.fragmentSize, "VkExtent2D", "fragmentSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.combinerOps, 2, "VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "VkFragmentShadingRateCombinerOpKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFragmentShadingRateCombinerOpKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineFragmentShadingRate, "VkBool32", "pipelineFragmentShadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveFragmentShadingRate, "VkBool32", "primitiveFragmentShadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.attachmentFragmentShadingRate, "VkBool32", "attachmentFragmentShadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minFragmentShadingRateAttachmentTexelSize, "VkExtent2D", "minFragmentShadingRateAttachmentTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxFragmentShadingRateAttachmentTexelSize, "VkExtent2D", "maxFragmentShadingRateAttachmentTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, "uint32_t", "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveFragmentShadingRateWithMultipleViewports, "VkBool32", "primitiveFragmentShadingRateWithMultipleViewports", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.layeredShadingRateAttachments, "VkBool32", "layeredShadingRateAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateNonTrivialCombinerOps, "VkBool32", "fragmentShadingRateNonTrivialCombinerOps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxFragmentSize, "VkExtent2D", "maxFragmentSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentSizeAspectRatio, "uint32_t", "maxFragmentSizeAspectRatio", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentShadingRateCoverageSamples, "uint32_t", "maxFragmentShadingRateCoverageSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.maxFragmentShadingRateRasterizationSamples, "VkSampleCountFlagBits", "maxFragmentShadingRateRasterizationSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateWithShaderDepthStencilWrites, "VkBool32", "fragmentShadingRateWithShaderDepthStencilWrites", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateWithSampleMask, "VkBool32", "fragmentShadingRateWithSampleMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateWithShaderSampleMask, "VkBool32", "fragmentShadingRateWithShaderSampleMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateWithConservativeRasterization, "VkBool32", "fragmentShadingRateWithConservativeRasterization", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateWithFragmentShaderInterlock, "VkBool32", "fragmentShadingRateWithFragmentShaderInterlock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateWithCustomSampleLocations, "VkBool32", "fragmentShadingRateWithCustomSampleLocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateStrictMultiplyCombiner, "VkBool32", "fragmentShadingRateStrictMultiplyCombiner", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShadingRateKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShadingRateKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampleCounts, "VkSampleCountFlags", "sampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.fragmentSize, "VkExtent2D", "fragmentSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingFragmentShadingRateAttachmentInfoKHR(ApiDumpInstance& api_dump, const VkRenderingFragmentShadingRateAttachmentInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.imageLayout, "VkImageLayout", "imageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.shadingRateAttachmentTexelSize, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderQuadControlFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderQuadControlFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderQuadControl, "VkBool32", "shaderQuadControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceProtectedCapabilitiesKHR(ApiDumpInstance& api_dump, const VkSurfaceProtectedCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.supportsProtected, "VkBool32", "supportsProtected", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentWaitFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentWaitFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentWait, "VkBool32", "presentWait", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineExecutableInfo, "VkBool32", "pipelineExecutableInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineInfoKHR(ApiDumpInstance& api_dump, const VkPipelineInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineExecutablePropertiesKHR(ApiDumpInstance& api_dump, const VkPipelineExecutablePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stages, "VkShaderStageFlags", "stages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subgroupSize, "uint32_t", "subgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineExecutableInfoKHR(ApiDumpInstance& api_dump, const VkPipelineExecutableInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.executableIndex, "uint32_t", "executableIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineExecutableStatisticValueKHR(ApiDumpInstance& api_dump, const VkPipelineExecutableStatisticValueKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_type<VkBool32>(api_dump, object.b32, "VkBool32", "b32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.i64, "int64_t", "i64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.u64, "uint64_t", "u64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<double>(api_dump, object.f64, "double", "f64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineExecutableStatisticKHR(ApiDumpInstance& api_dump, const VkPipelineExecutableStatisticKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineExecutableStatisticFormatKHR(api_dump, object.format, "VkPipelineExecutableStatisticFormatKHR", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineExecutableStatisticValueKHR(api_dump, object.value, "VkPipelineExecutableStatisticValueKHR", "value", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineExecutableInternalRepresentationKHR(ApiDumpInstance& api_dump, const VkPipelineExecutableInternalRepresentationKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.isText, "VkBool32", "isText", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dataSize, "size_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pData, "void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineLibraryCreateInfoKHR(ApiDumpInstance& api_dump, const VkPipelineLibraryCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.libraryCount, "uint32_t", "libraryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pLibraries, object.libraryCount, "const VkPipeline*", "pLibraries", "const VkPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipeline);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentIdKHR(ApiDumpInstance& api_dump, const VkPresentIdKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentIds, object.swapchainCount, "const uint64_t*", "pPresentIds", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentIdFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentIdFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentId, "VkBool32", "presentId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeFlagsKHR(api_dump, object.flags, "VkVideoEncodeFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.dstBuffer, "VkBuffer", "dstBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.dstBufferOffset, "VkDeviceSize", "dstBufferOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.dstBufferRange, "VkDeviceSize", "dstBufferRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoPictureResourceInfoKHR(api_dump, object.srcPictureResource, "VkVideoPictureResourceInfoKHR", "srcPictureResource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSetupReferenceSlot, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.referenceSlotCount, "uint32_t", "referenceSlotCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReferenceSlots, object.referenceSlotCount, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.precedingExternallyEncodedBytes, "uint32_t", "precedingExternallyEncodedBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeCapabilityFlagsKHR(api_dump, object.flags, "VkVideoEncodeCapabilityFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRateControlModeFlagsKHR(api_dump, object.rateControlModes, "VkVideoEncodeRateControlModeFlagsKHR", "rateControlModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRateControlLayers, "uint32_t", "maxRateControlLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxBitrate, "uint64_t", "maxBitrate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxQualityLevels, "uint32_t", "maxQualityLevels", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.encodeInputPictureGranularity, "VkExtent2D", "encodeInputPictureGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeFeedbackFlagsKHR(api_dump, object.supportedEncodeFeedbackFlags, "VkVideoEncodeFeedbackFlagsKHR", "supportedEncodeFeedbackFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(ApiDumpInstance& api_dump, const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeFeedbackFlagsKHR(api_dump, object.encodeFeedbackFlags, "VkVideoEncodeFeedbackFlagsKHR", "encodeFeedbackFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeUsageInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeUsageInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeUsageFlagsKHR(api_dump, object.videoUsageHints, "VkVideoEncodeUsageFlagsKHR", "videoUsageHints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeContentFlagsKHR(api_dump, object.videoContentHints, "VkVideoEncodeContentFlagsKHR", "videoContentHints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeTuningModeKHR(api_dump, object.tuningMode, "VkVideoEncodeTuningModeKHR", "tuningMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeRateControlLayerInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeRateControlLayerInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.averageBitrate, "uint64_t", "averageBitrate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxBitrate, "uint64_t", "maxBitrate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frameRateNumerator, "uint32_t", "frameRateNumerator", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frameRateDenominator, "uint32_t", "frameRateDenominator", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeRateControlInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeRateControlInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRateControlFlagsKHR(api_dump, object.flags, "VkVideoEncodeRateControlFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRateControlModeFlagBitsKHR(api_dump, object.rateControlMode, "VkVideoEncodeRateControlModeFlagBitsKHR", "rateControlMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layerCount, "uint32_t", "layerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pLayers, object.layerCount, "const VkVideoEncodeRateControlLayerInfoKHR*", "pLayers", "const VkVideoEncodeRateControlLayerInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeRateControlLayerInfoKHR);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.virtualBufferSizeInMs, "uint32_t", "virtualBufferSizeInMs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.initialVirtualBufferSizeInMs, "uint32_t", "initialVirtualBufferSizeInMs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pVideoProfile, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.qualityLevel, "uint32_t", "qualityLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeQualityLevelPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRateControlModeFlagBitsKHR(api_dump, object.preferredRateControlMode, "VkVideoEncodeRateControlModeFlagBitsKHR", "preferredRateControlMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredRateControlLayerCount, "uint32_t", "preferredRateControlLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeQualityLevelInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeQualityLevelInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.qualityLevel, "uint32_t", "qualityLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeSessionParametersGetInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeSessionParametersGetInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoSessionParametersKHR(api_dump, object.videoSessionParameters, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeSessionParametersFeedbackInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeSessionParametersFeedbackInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasOverrides, "VkBool32", "hasOverrides", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShaderBarycentric, "VkBool32", "fragmentShaderBarycentric", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.triStripVertexOrderIndependentOfProvokingVertex, "VkBool32", "triStripVertexOrderIndependentOfProvokingVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupUniformControlFlow, "VkBool32", "shaderSubgroupUniformControlFlow", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.workgroupMemoryExplicitLayout, "VkBool32", "workgroupMemoryExplicitLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.workgroupMemoryExplicitLayoutScalarBlockLayout, "VkBool32", "workgroupMemoryExplicitLayoutScalarBlockLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.workgroupMemoryExplicitLayout8BitAccess, "VkBool32", "workgroupMemoryExplicitLayout8BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.workgroupMemoryExplicitLayout16BitAccess, "VkBool32", "workgroupMemoryExplicitLayout16BitAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingMaintenance1, "VkBool32", "rayTracingMaintenance1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingPipelineTraceRaysIndirect2, "VkBool32", "rayTracingPipelineTraceRaysIndirect2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTraceRaysIndirectCommand2KHR(ApiDumpInstance& api_dump, const VkTraceRaysIndirectCommand2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.raygenShaderRecordAddress, "VkDeviceAddress", "raygenShaderRecordAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.raygenShaderRecordSize, "VkDeviceSize", "raygenShaderRecordSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.missShaderBindingTableAddress, "VkDeviceAddress", "missShaderBindingTableAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.missShaderBindingTableSize, "VkDeviceSize", "missShaderBindingTableSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.missShaderBindingTableStride, "VkDeviceSize", "missShaderBindingTableStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.hitShaderBindingTableAddress, "VkDeviceAddress", "hitShaderBindingTableAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.hitShaderBindingTableSize, "VkDeviceSize", "hitShaderBindingTableSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.hitShaderBindingTableStride, "VkDeviceSize", "hitShaderBindingTableStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.callableShaderBindingTableAddress, "VkDeviceAddress", "callableShaderBindingTableAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.callableShaderBindingTableSize, "VkDeviceSize", "callableShaderBindingTableSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.callableShaderBindingTableStride, "VkDeviceSize", "callableShaderBindingTableStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.depth, "uint32_t", "depth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUntypedPointers, "VkBool32", "shaderUntypedPointers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderMaximalReconvergence, "VkBool32", "shaderMaximalReconvergence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilitiesPresentId2KHR(ApiDumpInstance& api_dump, const VkSurfaceCapabilitiesPresentId2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentId2Supported, "VkBool32", "presentId2Supported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentId2KHR(ApiDumpInstance& api_dump, const VkPresentId2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentIds, object.swapchainCount, "const uint64_t*", "pPresentIds", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentId2FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentId2FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentId2, "VkBool32", "presentId2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilitiesPresentWait2KHR(ApiDumpInstance& api_dump, const VkSurfaceCapabilitiesPresentWait2KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentWait2Supported, "VkBool32", "presentWait2Supported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentWait2FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentWait2FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentWait2, "VkBool32", "presentWait2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentWait2InfoKHR(ApiDumpInstance& api_dump, const VkPresentWait2InfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentId, "uint64_t", "presentId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeout, "uint64_t", "timeout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingPositionFetch, "VkBool32", "rayTracingPositionFetch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineBinaryFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineBinaryFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineBinaries, "VkBool32", "pipelineBinaries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineBinaryPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineBinaryPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineBinaryInternalCache, "VkBool32", "pipelineBinaryInternalCache", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineBinaryInternalCacheControl, "VkBool32", "pipelineBinaryInternalCacheControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineBinaryPrefersInternalCache, "VkBool32", "pipelineBinaryPrefersInternalCache", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineBinaryPrecompiledInternalCache, "VkBool32", "pipelineBinaryPrecompiledInternalCache", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineBinaryCompressedData, "VkBool32", "pipelineBinaryCompressedData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDevicePipelineBinaryInternalCacheControlKHR(ApiDumpInstance& api_dump, const VkDevicePipelineBinaryInternalCacheControlKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.disableInternalCache, "VkBool32", "disableInternalCache", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryKeyKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryKeyKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.keySize, "uint32_t", "keySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR, "uint8_t[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]", "key", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryDataKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryDataKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<size_t>(api_dump, object.dataSize, "size_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pData, "void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryKeysAndDataKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryKeysAndDataKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.binaryCount, "uint32_t", "binaryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPipelineBinaryKeys, object.binaryCount, "const VkPipelineBinaryKeyKHR*", "pPipelineBinaryKeys", "const VkPipelineBinaryKeyKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKeyKHR);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPipelineBinaryData, object.binaryCount, "const VkPipelineBinaryDataKHR*", "pPipelineBinaryData", "const VkPipelineBinaryDataKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryDataKHR);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCreateInfoKHR(ApiDumpInstance& api_dump, const VkPipelineCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryCreateInfoKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pKeysAndDataInfo, "const VkPipelineBinaryKeysAndDataKHR*", "pKeysAndDataInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKeysAndDataKHR);
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pPipelineCreateInfo, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreateInfoKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryInfoKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.binaryCount, "uint32_t", "binaryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPipelineBinaries, object.binaryCount, "const VkPipelineBinaryKHR*", "pPipelineBinaries", "const VkPipelineBinaryKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkReleaseCapturedPipelineDataInfoKHR(ApiDumpInstance& api_dump, const VkReleaseCapturedPipelineDataInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryDataInfoKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryDataInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBinaryKHR(api_dump, object.pipelineBinary, "VkPipelineBinaryKHR", "pipelineBinary", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineBinaryHandlesInfoKHR(ApiDumpInstance& api_dump, const VkPipelineBinaryHandlesInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pipelineBinaryCount, "uint32_t", "pipelineBinaryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPipelineBinaries, object.pipelineBinaryCount, "VkPipelineBinaryKHR*", "pPipelineBinaries", "VkPipelineBinaryKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfacePresentModeKHR(ApiDumpInstance& api_dump, const VkSurfacePresentModeKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentModeKHR(api_dump, object.presentMode, "VkPresentModeKHR", "presentMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfacePresentScalingCapabilitiesKHR(ApiDumpInstance& api_dump, const VkSurfacePresentScalingCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentScalingFlagsKHR(api_dump, object.supportedPresentScaling, "VkPresentScalingFlagsKHR", "supportedPresentScaling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentGravityFlagsKHR(api_dump, object.supportedPresentGravityX, "VkPresentGravityFlagsKHR", "supportedPresentGravityX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentGravityFlagsKHR(api_dump, object.supportedPresentGravityY, "VkPresentGravityFlagsKHR", "supportedPresentGravityY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minScaledImageExtent, "VkExtent2D", "minScaledImageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxScaledImageExtent, "VkExtent2D", "maxScaledImageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfacePresentModeCompatibilityKHR(ApiDumpInstance& api_dump, const VkSurfacePresentModeCompatibilityKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.presentModeCount, "uint32_t", "presentModeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentModes, object.presentModeCount, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.swapchainMaintenance1, "VkBool32", "swapchainMaintenance1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainPresentFenceInfoKHR(ApiDumpInstance& api_dump, const VkSwapchainPresentFenceInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pFences, object.swapchainCount, "const VkFence*", "pFences", "const VkFence", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFence);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainPresentModesCreateInfoKHR(ApiDumpInstance& api_dump, const VkSwapchainPresentModesCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.presentModeCount, "uint32_t", "presentModeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentModes, object.presentModeCount, "const VkPresentModeKHR*", "pPresentModes", "const VkPresentModeKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainPresentModeInfoKHR(ApiDumpInstance& api_dump, const VkSwapchainPresentModeInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentModes, object.swapchainCount, "const VkPresentModeKHR*", "pPresentModes", "const VkPresentModeKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainPresentScalingCreateInfoKHR(ApiDumpInstance& api_dump, const VkSwapchainPresentScalingCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentScalingFlagsKHR(api_dump, object.scalingBehavior, "VkPresentScalingFlagsKHR", "scalingBehavior", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentGravityFlagsKHR(api_dump, object.presentGravityX, "VkPresentGravityFlagsKHR", "presentGravityX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentGravityFlagsKHR(api_dump, object.presentGravityY, "VkPresentGravityFlagsKHR", "presentGravityY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkReleaseSwapchainImagesInfoKHR(ApiDumpInstance& api_dump, const VkReleaseSwapchainImagesInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.swapchain, "VkSwapchainKHR", "swapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageIndexCount, "uint32_t", "imageIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImageIndices, object.imageIndexCount, "const uint32_t*", "pImageIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.internallySynchronizedQueues, "VkBool32", "internallySynchronizedQueues", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCooperativeMatrixPropertiesKHR(ApiDumpInstance& api_dump, const VkCooperativeMatrixPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.MSize, "uint32_t", "MSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.NSize, "uint32_t", "NSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.KSize, "uint32_t", "KSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.AType, "VkComponentTypeKHR", "AType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.BType, "VkComponentTypeKHR", "BType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.CType, "VkComponentTypeKHR", "CType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.ResultType, "VkComponentTypeKHR", "ResultType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.saturatingAccumulation, "VkBool32", "saturatingAccumulation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkScopeKHR(api_dump, object.scope, "VkScopeKHR", "scope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrix, "VkBool32", "cooperativeMatrix", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixRobustBufferAccess, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.cooperativeMatrixSupportedStages, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.computeDerivativeGroupQuads, "VkBool32", "computeDerivativeGroupQuads", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.computeDerivativeGroupLinear, "VkBool32", "computeDerivativeGroupLinear", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.meshAndTaskShaderDerivatives, "VkBool32", "meshAndTaskShaderDerivatives", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeAV1ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeAV1ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1Profile(api_dump, object.stdProfile, "StdVideoAV1Profile", "stdProfile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filmGrainSupport, "VkBool32", "filmGrainSupport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeAV1CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoDecodeAV1CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1Level(api_dump, object.maxLevel, "StdVideoAV1Level", "maxLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeAV1SessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeAV1SessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSequenceHeader, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeAV1PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeAV1PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoDecodeAV1PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeAV1PictureInfo);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.frameHeaderOffset, "uint32_t", "frameHeaderOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tileCount, "uint32_t", "tileCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTileOffsets, object.tileCount, "const uint32_t*", "pTileOffsets", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTileSizes, object.tileCount, "const uint32_t*", "pTileSizes", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeAV1DpbSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeAV1DpbSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdReferenceInfo, "const StdVideoDecodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeAV1ReferenceInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoEncodeAV1, "VkBool32", "videoEncodeAV1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1CapabilityFlagsKHR(api_dump, object.flags, "VkVideoEncodeAV1CapabilityFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1Level(api_dump, object.maxLevel, "StdVideoAV1Level", "maxLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.codedPictureAlignment, "VkExtent2D", "codedPictureAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxTiles, "VkExtent2D", "maxTiles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minTileSize, "VkExtent2D", "minTileSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxTileSize, "VkExtent2D", "maxTileSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(api_dump, object.superblockSizes, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "superblockSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSingleReferenceCount, "uint32_t", "maxSingleReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.singleReferenceNameMask, "uint32_t", "singleReferenceNameMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxUnidirectionalCompoundReferenceCount, "uint32_t", "maxUnidirectionalCompoundReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxUnidirectionalCompoundGroup1ReferenceCount, "uint32_t", "maxUnidirectionalCompoundGroup1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.unidirectionalCompoundReferenceNameMask, "uint32_t", "unidirectionalCompoundReferenceNameMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBidirectionalCompoundReferenceCount, "uint32_t", "maxBidirectionalCompoundReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBidirectionalCompoundGroup1ReferenceCount, "uint32_t", "maxBidirectionalCompoundGroup1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBidirectionalCompoundGroup2ReferenceCount, "uint32_t", "maxBidirectionalCompoundGroup2ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bidirectionalCompoundReferenceNameMask, "uint32_t", "bidirectionalCompoundReferenceNameMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTemporalLayerCount, "uint32_t", "maxTemporalLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSpatialLayerCount, "uint32_t", "maxSpatialLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxOperatingPoints, "uint32_t", "maxOperatingPoints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minQIndex, "uint32_t", "minQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxQIndex, "uint32_t", "maxQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersGopRemainingFrames, "VkBool32", "prefersGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.requiresGopRemainingFrames, "VkBool32", "requiresGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1StdFlagsKHR(api_dump, object.stdSyntaxFlags, "VkVideoEncodeAV1StdFlagsKHR", "stdSyntaxFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1QIndexKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1QIndexKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.intraQIndex, "uint32_t", "intraQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.predictiveQIndex, "uint32_t", "predictiveQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bipredictiveQIndex, "uint32_t", "bipredictiveQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1QualityLevelPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1QualityLevelPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1RateControlFlagsKHR(api_dump, object.preferredRateControlFlags, "VkVideoEncodeAV1RateControlFlagsKHR", "preferredRateControlFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredGopFrameCount, "uint32_t", "preferredGopFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredKeyFramePeriod, "uint32_t", "preferredKeyFramePeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredConsecutiveBipredictiveFrameCount, "uint32_t", "preferredConsecutiveBipredictiveFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredTemporalLayerCount, "uint32_t", "preferredTemporalLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1QIndexKHR(api_dump, object.preferredConstantQIndex, "VkVideoEncodeAV1QIndexKHR", "preferredConstantQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxSingleReferenceCount, "uint32_t", "preferredMaxSingleReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredSingleReferenceNameMask, "uint32_t", "preferredSingleReferenceNameMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxUnidirectionalCompoundReferenceCount, "uint32_t", "preferredMaxUnidirectionalCompoundReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxUnidirectionalCompoundGroup1ReferenceCount, "uint32_t", "preferredMaxUnidirectionalCompoundGroup1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredUnidirectionalCompoundReferenceNameMask, "uint32_t", "preferredUnidirectionalCompoundReferenceNameMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxBidirectionalCompoundReferenceCount, "uint32_t", "preferredMaxBidirectionalCompoundReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxBidirectionalCompoundGroup1ReferenceCount, "uint32_t", "preferredMaxBidirectionalCompoundGroup1ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredMaxBidirectionalCompoundGroup2ReferenceCount, "uint32_t", "preferredMaxBidirectionalCompoundGroup2ReferenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.preferredBidirectionalCompoundReferenceNameMask, "uint32_t", "preferredBidirectionalCompoundReferenceNameMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1SessionCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1SessionCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxLevel, "VkBool32", "useMaxLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1Level(api_dump, object.maxLevel, "StdVideoAV1Level", "maxLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1SessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1SessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSequenceHeader, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdDecoderModelInfo, "const StdVideoEncodeAV1DecoderModelInfo*", "pStdDecoderModelInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1DecoderModelInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stdOperatingPointCount, "uint32_t", "stdOperatingPointCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStdOperatingPoints, object.stdOperatingPointCount, "const StdVideoEncodeAV1OperatingPointInfo*", "pStdOperatingPoints", "const StdVideoEncodeAV1OperatingPointInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1OperatingPointInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1PredictionModeKHR(api_dump, object.predictionMode, "VkVideoEncodeAV1PredictionModeKHR", "predictionMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1RateControlGroupKHR(api_dump, object.rateControlGroup, "VkVideoEncodeAV1RateControlGroupKHR", "rateControlGroup", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constantQIndex, "uint32_t", "constantQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoEncodeAV1PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1PictureInfo);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primaryReferenceCdfOnly, "VkBool32", "primaryReferenceCdfOnly", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.generateObuExtensionHeader, "VkBool32", "generateObuExtensionHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1DpbSlotInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1DpbSlotInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdReferenceInfo, "const StdVideoEncodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ReferenceInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoAV1Profile(api_dump, object.stdProfile, "StdVideoAV1Profile", "stdProfile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1FrameSizeKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1FrameSizeKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.intraFrameSize, "uint32_t", "intraFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.predictiveFrameSize, "uint32_t", "predictiveFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bipredictiveFrameSize, "uint32_t", "bipredictiveFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1GopRemainingFrameInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1GopRemainingFrameInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useGopRemainingFrames, "VkBool32", "useGopRemainingFrames", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingIntra, "uint32_t", "gopRemainingIntra", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingPredictive, "uint32_t", "gopRemainingPredictive", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopRemainingBipredictive, "uint32_t", "gopRemainingBipredictive", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1RateControlInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1RateControlInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1RateControlFlagsKHR(api_dump, object.flags, "VkVideoEncodeAV1RateControlFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gopFrameCount, "uint32_t", "gopFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.keyFramePeriod, "uint32_t", "keyFramePeriod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.consecutiveBipredictiveFrameCount, "uint32_t", "consecutiveBipredictiveFrameCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.temporalLayerCount, "uint32_t", "temporalLayerCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1RateControlLayerInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1RateControlLayerInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMinQIndex, "VkBool32", "useMinQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1QIndexKHR(api_dump, object.minQIndex, "VkVideoEncodeAV1QIndexKHR", "minQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxQIndex, "VkBool32", "useMaxQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1QIndexKHR(api_dump, object.maxQIndex, "VkVideoEncodeAV1QIndexKHR", "maxQIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useMaxFrameSize, "VkBool32", "useMaxFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1FrameSizeKHR(api_dump, object.maxFrameSize, "VkVideoEncodeAV1FrameSizeKHR", "maxFrameSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoDecodeVP9, "VkBool32", "videoDecodeVP9", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeVP9ProfileInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeVP9ProfileInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoVP9Profile(api_dump, object.stdProfile, "StdVideoVP9Profile", "stdProfile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeVP9CapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoDecodeVP9CapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_StdVideoVP9Level(api_dump, object.maxLevel, "StdVideoVP9Level", "maxLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeVP9PictureInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeVP9PictureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPictureInfo, "const StdVideoDecodeVP9PictureInfo*", "pStdPictureInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeVP9PictureInfo);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.referenceNameSlotIndices, VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR, "int32_t[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<int32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.uncompressedHeaderOffset, "uint32_t", "uncompressedHeaderOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.compressedHeaderOffset, "uint32_t", "compressedHeaderOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tilesOffset, "uint32_t", "tilesOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoMaintenance1, "VkBool32", "videoMaintenance1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoInlineQueryInfoKHR(ApiDumpInstance& api_dump, const VkVideoInlineQueryInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryPool(api_dump, object.queryPool, "VkQueryPool", "queryPool", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstQuery, "uint32_t", "firstQuery", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queryCount, "uint32_t", "queryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.unifiedImageLayouts, "VkBool32", "unifiedImageLayouts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.unifiedImageLayoutsVideo, "VkBool32", "unifiedImageLayoutsVideo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentFeedbackLoopInfoEXT(ApiDumpInstance& api_dump, const VkAttachmentFeedbackLoopInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.feedbackLoopEnable, "VkBool32", "feedbackLoopEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCalibratedTimestampInfoKHR(ApiDumpInstance& api_dump, const VkCalibratedTimestampInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTimeDomainKHR(api_dump, object.timeDomain, "VkTimeDomainKHR", "timeDomain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSetDescriptorBufferOffsetsInfoEXT(ApiDumpInstance& api_dump, const VkSetDescriptorBufferOffsetsInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstSet, "uint32_t", "firstSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.setCount, "uint32_t", "setCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBufferIndices, object.setCount, "const uint32_t*", "pBufferIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pOffsets, object.setCount, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const VkDeviceSize>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(ApiDumpInstance& api_dump, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.stageFlags, "VkShaderStageFlags", "stageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.set, "uint32_t", "set", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkStridedDeviceAddressRangeKHR(ApiDumpInstance& api_dump, const VkStridedDeviceAddressRangeKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.address, "VkDeviceAddress", "address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.stride, "VkDeviceSize", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryIndirectCommandKHR(ApiDumpInstance& api_dump, const VkCopyMemoryIndirectCommandKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcAddress, "VkDeviceAddress", "srcAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.dstAddress, "VkDeviceAddress", "dstAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryIndirectInfoKHR(ApiDumpInstance& api_dump, const VkCopyMemoryIndirectInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAddressCopyFlagsKHR(api_dump, object.srcCopyFlags, "VkAddressCopyFlagsKHR", "srcCopyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAddressCopyFlagsKHR(api_dump, object.dstCopyFlags, "VkAddressCopyFlagsKHR", "dstCopyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.copyCount, "uint32_t", "copyCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressRangeKHR(api_dump, object.copyAddressRange, "VkStridedDeviceAddressRangeKHR", "copyAddressRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryToImageIndirectCommandKHR(ApiDumpInstance& api_dump, const VkCopyMemoryToImageIndirectCommandKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcAddress, "VkDeviceAddress", "srcAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferRowLength, "uint32_t", "bufferRowLength", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferImageHeight, "uint32_t", "bufferImageHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageSubresourceLayers(api_dump, object.imageSubresource, "VkImageSubresourceLayers", "imageSubresource", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset3D(api_dump, object.imageOffset, "VkOffset3D", "imageOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.imageExtent, "VkExtent3D", "imageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryToImageIndirectInfoKHR(ApiDumpInstance& api_dump, const VkCopyMemoryToImageIndirectInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAddressCopyFlagsKHR(api_dump, object.srcCopyFlags, "VkAddressCopyFlagsKHR", "srcCopyFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.copyCount, "uint32_t", "copyCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressRangeKHR(api_dump, object.copyAddressRange, "VkStridedDeviceAddressRangeKHR", "copyAddressRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.dstImage, "VkImage", "dstImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.dstImageLayout, "VkImageLayout", "dstImageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImageSubresources, object.copyCount, "const VkImageSubresourceLayers*", "pImageSubresources", "const VkImageSubresourceLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageSubresourceLayers);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.indirectMemoryCopy, "VkBool32", "indirectMemoryCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.indirectMemoryToImageCopy, "VkBool32", "indirectMemoryToImageCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueueFlags(api_dump, object.supportedQueues, "VkQueueFlags", "supportedQueues", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeIntraRefreshCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeIntraRefreshCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeIntraRefreshModeFlagsKHR(api_dump, object.intraRefreshModes, "VkVideoEncodeIntraRefreshModeFlagsKHR", "intraRefreshModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIntraRefreshCycleDuration, "uint32_t", "maxIntraRefreshCycleDuration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIntraRefreshActiveReferencePictures, "uint32_t", "maxIntraRefreshActiveReferencePictures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.partitionIndependentIntraRefreshRegions, "VkBool32", "partitionIndependentIntraRefreshRegions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nonRectangularIntraRefreshRegions, "VkBool32", "nonRectangularIntraRefreshRegions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeSessionIntraRefreshCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(api_dump, object.intraRefreshMode, "VkVideoEncodeIntraRefreshModeFlagBitsKHR", "intraRefreshMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeIntraRefreshInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeIntraRefreshInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intraRefreshCycleDuration, "uint32_t", "intraRefreshCycleDuration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intraRefreshIndex, "uint32_t", "intraRefreshIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoReferenceIntraRefreshInfoKHR(ApiDumpInstance& api_dump, const VkVideoReferenceIntraRefreshInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dirtyIntraRefreshRegions, "uint32_t", "dirtyIntraRefreshRegions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoEncodeIntraRefresh, "VkBool32", "videoEncodeIntraRefresh", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeQuantizationMapCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeQuantizationMapCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxQuantizationMapExtent, "VkExtent2D", "maxQuantizationMapExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoFormatQuantizationMapPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoFormatQuantizationMapPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.quantizationMapTexelSize, "VkExtent2D", "quantizationMapTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeQuantizationMapInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeQuantizationMapInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.quantizationMap, "VkImageView", "quantizationMap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.quantizationMapExtent, "VkExtent2D", "quantizationMapExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(ApiDumpInstance& api_dump, const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.quantizationMapTexelSize, "VkExtent2D", "quantizationMapTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoEncodeQuantizationMap, "VkBool32", "videoEncodeQuantizationMap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH264QuantizationMapCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minQpDelta, "int32_t", "minQpDelta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.maxQpDelta, "int32_t", "maxQpDelta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeH265QuantizationMapCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minQpDelta, "int32_t", "minQpDelta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.maxQpDelta, "int32_t", "maxQpDelta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoFormatH265QuantizationMapPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoFormatH265QuantizationMapPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeH265CtbSizeFlagsKHR(api_dump, object.compatibleCtbSizes, "VkVideoEncodeH265CtbSizeFlagsKHR", "compatibleCtbSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(ApiDumpInstance& api_dump, const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.minQIndexDelta, "int32_t", "minQIndexDelta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.maxQIndexDelta, "int32_t", "maxQIndexDelta", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoFormatAV1QuantizationMapPropertiesKHR(ApiDumpInstance& api_dump, const VkVideoFormatAV1QuantizationMapPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(api_dump, object.compatibleSuperblockSizes, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "compatibleSuperblockSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRelaxedExtendedInstruction, "VkBool32", "shaderRelaxedExtendedInstruction", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance7FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance7FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance7, "VkBool32", "maintenance7", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance7PropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance7PropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustFragmentShadingRateAttachmentAccess, "VkBool32", "robustFragmentShadingRateAttachmentAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.separateDepthStencilAttachmentAccess, "VkBool32", "separateDepthStencilAttachmentAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetTotalUniformBuffersDynamic, "uint32_t", "maxDescriptorSetTotalUniformBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetTotalStorageBuffersDynamic, "uint32_t", "maxDescriptorSetTotalStorageBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetTotalBuffersDynamic, "uint32_t", "maxDescriptorSetTotalBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLayeredApiPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceLayeredApiPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vendorID, "uint32_t", "vendorID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceID, "uint32_t", "deviceID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceLayeredApiKHR(api_dump, object.layeredAPI, "VkPhysicalDeviceLayeredApiKHR", "layeredAPI", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.deviceName, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLayeredApiPropertiesListKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceLayeredApiPropertiesListKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.layeredApiCount, "uint32_t", "layeredApiCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pLayeredApis, object.layeredApiCount, "VkPhysicalDeviceLayeredApiPropertiesKHR*", "pLayeredApis", "VkPhysicalDeviceLayeredApiPropertiesKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceLayeredApiPropertiesKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceProperties2(api_dump, object.properties, "VkPhysicalDeviceProperties2", "properties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryBarrierAccessFlags3KHR(ApiDumpInstance& api_dump, const VkMemoryBarrierAccessFlags3KHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags3KHR(api_dump, object.srcAccessMask3, "VkAccessFlags3KHR", "srcAccessMask3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags3KHR(api_dump, object.dstAccessMask3, "VkAccessFlags3KHR", "dstAccessMask3", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance8FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance8FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance8, "VkBool32", "maintenance8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderFmaFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderFmaFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFmaFloat16, "VkBool32", "shaderFmaFloat16", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFmaFloat32, "VkBool32", "shaderFmaFloat32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFmaFloat64, "VkBool32", "shaderFmaFloat64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance9FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance9FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance9, "VkBool32", "maintenance9", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance9PropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance9PropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.image2DViewOf3DSparse, "VkBool32", "image2DViewOf3DSparse", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDefaultVertexAttributeValueKHR(api_dump, object.defaultVertexAttributeValue, "VkDefaultVertexAttributeValueKHR", "defaultVertexAttributeValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyOwnershipTransferPropertiesKHR(ApiDumpInstance& api_dump, const VkQueueFamilyOwnershipTransferPropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.optimalImageTransferToQueueFamilies, "uint32_t", "optimalImageTransferToQueueFamilies", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoMaintenance2FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoMaintenance2, "VkBool32", "videoMaintenance2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH264InlineSessionParametersInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH264InlineSessionParametersInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSPS, "const StdVideoH264SequenceParameterSet*", "pStdSPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPPS, "const StdVideoH264PictureParameterSet*", "pStdPPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeH265InlineSessionParametersInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeH265InlineSessionParametersInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdVPS, "const StdVideoH265VideoParameterSet*", "pStdVPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSPS, "const StdVideoH265SequenceParameterSet*", "pStdSPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdPPS, "const StdVideoH265PictureParameterSet*", "pStdPPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoDecodeAV1InlineSessionParametersInfoKHR(ApiDumpInstance& api_dump, const VkVideoDecodeAV1InlineSessionParametersInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pStdSequenceHeader, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClampZeroOne, "VkBool32", "depthClampZeroOne", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRobustness2FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRobustness2FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustBufferAccess2, "VkBool32", "robustBufferAccess2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.robustImageAccess2, "VkBool32", "robustImageAccess2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nullDescriptor, "VkBool32", "nullDescriptor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRobustness2PropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRobustness2PropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.robustStorageBufferAccessSizeAlignment, "VkDeviceSize", "robustStorageBufferAccessSizeAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.robustUniformBufferAccessSizeAlignment, "VkDeviceSize", "robustUniformBufferAccessSizeAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentModeFifoLatestReady, "VkBool32", "presentModeFifoLatestReady", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance10FeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance10FeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.maintenance10, "VkBool32", "maintenance10", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMaintenance10PropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceMaintenance10PropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rgba4OpaqueBlackSwizzled, "VkBool32", "rgba4OpaqueBlackSwizzled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.resolveSrgbFormatAppliesTransferFunction, "VkBool32", "resolveSrgbFormatAppliesTransferFunction", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.resolveSrgbFormatSupportsTransferFunctionControl, "VkBool32", "resolveSrgbFormatSupportsTransferFunctionControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingEndInfoKHR(ApiDumpInstance& api_dump, const VkRenderingEndInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingAttachmentFlagsInfoKHR(ApiDumpInstance& api_dump, const VkRenderingAttachmentFlagsInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderingAttachmentFlagsKHR(api_dump, object.flags, "VkRenderingAttachmentFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkResolveImageModeInfoKHR(ApiDumpInstance& api_dump, const VkResolveImageModeInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveImageFlagsKHR(api_dump, object.flags, "VkResolveImageFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlagBits(api_dump, object.resolveMode, "VkResolveModeFlagBits", "resolveMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResolveModeFlagBits(api_dump, object.stencilResolveMode, "VkResolveModeFlagBits", "stencilResolveMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugReportCallbackCreateInfoEXT(ApiDumpInstance& api_dump, const VkDebugReportCallbackCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugReportFlagsEXT(api_dump, object.flags, "VkDebugReportFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkDebugReportCallbackEXT(api_dump, object.pfnCallback, "PFN_vkDebugReportCallbackEXT", "pfnCallback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pUserData, "void*", "pUserData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationStateRasterizationOrderAMD(ApiDumpInstance& api_dump, const VkPipelineRasterizationStateRasterizationOrderAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRasterizationOrderAMD(api_dump, object.rasterizationOrder, "VkRasterizationOrderAMD", "rasterizationOrder", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugMarkerObjectNameInfoEXT(ApiDumpInstance& api_dump, const VkDebugMarkerObjectNameInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugReportObjectTypeEXT(api_dump, object.objectType, "VkDebugReportObjectTypeEXT", "objectType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.object, "uint64_t", "object", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pObjectName, "const char*", "pObjectName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugMarkerObjectTagInfoEXT(ApiDumpInstance& api_dump, const VkDebugMarkerObjectTagInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugReportObjectTypeEXT(api_dump, object.objectType, "VkDebugReportObjectTypeEXT", "objectType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.object, "uint64_t", "object", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.tagName, "uint64_t", "tagName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tagSize, "size_t", "tagSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pTag, "const void*", "pTag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugMarkerMarkerInfoEXT(ApiDumpInstance& api_dump, const VkDebugMarkerMarkerInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pMarkerName, "const char*", "pMarkerName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.color, 4, "float[4]", "color", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDedicatedAllocationImageCreateInfoNV(ApiDumpInstance& api_dump, const VkDedicatedAllocationImageCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dedicatedAllocation, "VkBool32", "dedicatedAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDedicatedAllocationBufferCreateInfoNV(ApiDumpInstance& api_dump, const VkDedicatedAllocationBufferCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dedicatedAllocation, "VkBool32", "dedicatedAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDedicatedAllocationMemoryAllocateInfoNV(ApiDumpInstance& api_dump, const VkDedicatedAllocationMemoryAllocateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTransformFeedbackFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceTransformFeedbackFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedback, "VkBool32", "transformFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.geometryStreams, "VkBool32", "geometryStreams", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTransformFeedbackPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceTransformFeedbackPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTransformFeedbackStreams, "uint32_t", "maxTransformFeedbackStreams", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTransformFeedbackBuffers, "uint32_t", "maxTransformFeedbackBuffers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxTransformFeedbackBufferSize, "VkDeviceSize", "maxTransformFeedbackBufferSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTransformFeedbackStreamDataSize, "uint32_t", "maxTransformFeedbackStreamDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTransformFeedbackBufferDataSize, "uint32_t", "maxTransformFeedbackBufferDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTransformFeedbackBufferDataStride, "uint32_t", "maxTransformFeedbackBufferDataStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedbackQueries, "VkBool32", "transformFeedbackQueries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedbackStreamsLinesTriangles, "VkBool32", "transformFeedbackStreamsLinesTriangles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedbackRasterizationStreamSelect, "VkBool32", "transformFeedbackRasterizationStreamSelect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedbackDraw, "VkBool32", "transformFeedbackDraw", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationStateStreamCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationStateStreamCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRasterizationStateStreamCreateFlagsEXT(api_dump, object.flags, "VkPipelineRasterizationStateStreamCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.rasterizationStream, "uint32_t", "rasterizationStream", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCuModuleCreateInfoNVX(ApiDumpInstance& api_dump, const VkCuModuleCreateInfoNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dataSize, "size_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pData, "const void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCuModuleTexturingModeCreateInfoNVX(ApiDumpInstance& api_dump, const VkCuModuleTexturingModeCreateInfoNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.use64bitTexturing, "VkBool32", "use64bitTexturing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCuFunctionCreateInfoNVX(ApiDumpInstance& api_dump, const VkCuFunctionCreateInfoNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCuModuleNVX(api_dump, object.module, "VkCuModuleNVX", "module", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pName, "const char*", "pName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCuLaunchInfoNVX(ApiDumpInstance& api_dump, const VkCuLaunchInfoNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCuFunctionNVX(api_dump, object.function, "VkCuFunctionNVX", "function", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gridDimX, "uint32_t", "gridDimX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gridDimY, "uint32_t", "gridDimY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gridDimZ, "uint32_t", "gridDimZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.blockDimX, "uint32_t", "blockDimX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.blockDimY, "uint32_t", "blockDimY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.blockDimZ, "uint32_t", "blockDimZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sharedMemBytes, "uint32_t", "sharedMemBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.paramCount, "size_t", "paramCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pParams, object.paramCount, "const void* const *", "pParams", "const void*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const void*>);
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.extraCount, "size_t", "extraCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pExtras, object.extraCount, "const void* const *", "pExtras", "const void*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const void*>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewHandleInfoNVX(ApiDumpInstance& api_dump, const VkImageViewHandleInfoNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorType(api_dump, object.descriptorType, "VkDescriptorType", "descriptorType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampler(api_dump, object.sampler, "VkSampler", "sampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewAddressPropertiesNVX(ApiDumpInstance& api_dump, const VkImageViewAddressPropertiesNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTextureLODGatherFormatPropertiesAMD(ApiDumpInstance& api_dump, const VkTextureLODGatherFormatPropertiesAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.supportsTextureGatherLODBiasAMD, "VkBool32", "supportsTextureGatherLODBiasAMD", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderResourceUsageAMD(ApiDumpInstance& api_dump, const VkShaderResourceUsageAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.numUsedVgprs, "uint32_t", "numUsedVgprs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numUsedSgprs, "uint32_t", "numUsedSgprs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.ldsSizePerLocalWorkGroup, "uint32_t", "ldsSizePerLocalWorkGroup", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.ldsUsageSizeInBytes, "size_t", "ldsUsageSizeInBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.scratchMemUsageInBytes, "size_t", "scratchMemUsageInBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderStatisticsInfoAMD(ApiDumpInstance& api_dump, const VkShaderStatisticsInfoAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkShaderStageFlags(api_dump, object.shaderStageMask, "VkShaderStageFlags", "shaderStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderResourceUsageAMD(api_dump, object.resourceUsage, "VkShaderResourceUsageAMD", "resourceUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numPhysicalVgprs, "uint32_t", "numPhysicalVgprs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numPhysicalSgprs, "uint32_t", "numPhysicalSgprs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numAvailableVgprs, "uint32_t", "numAvailableVgprs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numAvailableSgprs, "uint32_t", "numAvailableSgprs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.computeWorkGroupSize, 3, "uint32_t[3]", "computeWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, 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);
+void dump_VkStreamDescriptorSurfaceCreateInfoGGP(ApiDumpInstance& api_dump, const VkStreamDescriptorSurfaceCreateInfoGGP& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStreamDescriptorSurfaceCreateFlagsGGP(api_dump, object.flags, "VkStreamDescriptorSurfaceCreateFlagsGGP", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<GgpStreamDescriptor>(api_dump, object.streamDescriptor, "GgpStreamDescriptor", "streamDescriptor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceCornerSampledImageFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCornerSampledImageFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cornerSampledImage, "VkBool32", "cornerSampledImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalImageFormatPropertiesNV(ApiDumpInstance& api_dump, const VkExternalImageFormatPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkImageFormatProperties(api_dump, object.imageFormatProperties, "VkImageFormatProperties", "imageFormatProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryFeatureFlagsNV(api_dump, object.externalMemoryFeatures, "VkExternalMemoryFeatureFlagsNV", "externalMemoryFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, object.exportFromImportedHandleTypes, "VkExternalMemoryHandleTypeFlagsNV", "exportFromImportedHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, object.compatibleHandleTypes, "VkExternalMemoryHandleTypeFlagsNV", "compatibleHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalMemoryImageCreateInfoNV(ApiDumpInstance& api_dump, const VkExternalMemoryImageCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, object.handleTypes, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMemoryAllocateInfoNV(ApiDumpInstance& api_dump, const VkExportMemoryAllocateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, object.handleTypes, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportMemoryWin32HandleInfoNV(ApiDumpInstance& api_dump, const VkImportMemoryWin32HandleInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagsNV", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HANDLE>(api_dump, object.handle, "HANDLE", "handle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMemoryWin32HandleInfoNV(ApiDumpInstance& api_dump, const VkExportMemoryWin32HandleInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const SECURITY_ATTRIBUTES*>(api_dump, object.pAttributes, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<DWORD>(api_dump, object.dwAccess, "DWORD", "dwAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWin32KeyedMutexAcquireReleaseInfoNV(ApiDumpInstance& api_dump, const VkWin32KeyedMutexAcquireReleaseInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.acquireCount, "uint32_t", "acquireCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAcquireSyncs, object.acquireCount, "const VkDeviceMemory*", "pAcquireSyncs", "const VkDeviceMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAcquireKeys, object.acquireCount, "const uint64_t*", "pAcquireKeys", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAcquireTimeoutMilliseconds, object.acquireCount, "const uint32_t*", "pAcquireTimeoutMilliseconds", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.releaseCount, "uint32_t", "releaseCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReleaseSyncs, object.releaseCount, "const VkDeviceMemory*", "pReleaseSyncs", "const VkDeviceMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pReleaseKeys, object.releaseCount, "const uint64_t*", "pReleaseKeys", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkValidationFlagsEXT(ApiDumpInstance& api_dump, const VkValidationFlagsEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.disabledValidationCheckCount, "uint32_t", "disabledValidationCheckCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDisabledValidationChecks, object.disabledValidationCheckCount, "const VkValidationCheckEXT*", "pDisabledValidationChecks", "const VkValidationCheckEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationCheckEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkViSurfaceCreateInfoNN(ApiDumpInstance& api_dump, const VkViSurfaceCreateInfoNN& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkViSurfaceCreateFlagsNN(api_dump, object.flags, "VkViSurfaceCreateFlagsNN", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.window, "void*", "window", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImageViewASTCDecodeModeEXT(ApiDumpInstance& api_dump, const VkImageViewASTCDecodeModeEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.decodeMode, "VkFormat", "decodeMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceASTCDecodeFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceASTCDecodeFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.decodeModeSharedExponent, "VkBool32", "decodeModeSharedExponent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkConditionalRenderingBeginInfoEXT(ApiDumpInstance& api_dump, const VkConditionalRenderingBeginInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkConditionalRenderingFlagsEXT(api_dump, object.flags, "VkConditionalRenderingFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceConditionalRenderingFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceConditionalRenderingFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.conditionalRendering, "VkBool32", "conditionalRendering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.inheritedConditionalRendering, "VkBool32", "inheritedConditionalRendering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferInheritanceConditionalRenderingInfoEXT(ApiDumpInstance& api_dump, const VkCommandBufferInheritanceConditionalRenderingInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.conditionalRenderingEnable, "VkBool32", "conditionalRenderingEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkViewportWScalingNV(ApiDumpInstance& api_dump, const VkViewportWScalingNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.xcoeff, "float", "xcoeff", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.ycoeff, "float", "ycoeff", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportWScalingStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineViewportWScalingStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.viewportWScalingEnable, "VkBool32", "viewportWScalingEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewportCount, "uint32_t", "viewportCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pViewportWScalings, object.viewportCount, "const VkViewportWScalingNV*", "pViewportWScalings", "const VkViewportWScalingNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkViewportWScalingNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilities2EXT(ApiDumpInstance& api_dump, const VkSurfaceCapabilities2EXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minImageCount, "uint32_t", "minImageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageCount, "uint32_t", "maxImageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.currentExtent, "VkExtent2D", "currentExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minImageExtent, "VkExtent2D", "minImageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxImageExtent, "VkExtent2D", "maxImageExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxImageArrayLayers, "uint32_t", "maxImageArrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagsKHR(api_dump, object.supportedTransforms, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.currentTransform, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompositeAlphaFlagsKHR(api_dump, object.supportedCompositeAlpha, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.supportedUsageFlags, "VkImageUsageFlags", "supportedUsageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceCounterFlagsEXT(api_dump, object.supportedSurfaceCounters, "VkSurfaceCounterFlagsEXT", "supportedSurfaceCounters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayPowerInfoEXT(ApiDumpInstance& api_dump, const VkDisplayPowerInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayPowerStateEXT(api_dump, object.powerState, "VkDisplayPowerStateEXT", "powerState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceEventInfoEXT(ApiDumpInstance& api_dump, const VkDeviceEventInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceEventTypeEXT(api_dump, object.deviceEvent, "VkDeviceEventTypeEXT", "deviceEvent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayEventInfoEXT(ApiDumpInstance& api_dump, const VkDisplayEventInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplayEventTypeEXT(api_dump, object.displayEvent, "VkDisplayEventTypeEXT", "displayEvent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainCounterCreateInfoEXT(ApiDumpInstance& api_dump, const VkSwapchainCounterCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceCounterFlagsEXT(api_dump, object.surfaceCounters, "VkSurfaceCounterFlagsEXT", "surfaceCounters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRefreshCycleDurationGOOGLE(ApiDumpInstance& api_dump, const VkRefreshCycleDurationGOOGLE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint64_t>(api_dump, object.refreshDuration, "uint64_t", "refreshDuration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPastPresentationTimingGOOGLE(ApiDumpInstance& api_dump, const VkPastPresentationTimingGOOGLE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.presentID, "uint32_t", "presentID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.desiredPresentTime, "uint64_t", "desiredPresentTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.actualPresentTime, "uint64_t", "actualPresentTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.earliestPresentTime, "uint64_t", "earliestPresentTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentMargin, "uint64_t", "presentMargin", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentTimeGOOGLE(ApiDumpInstance& api_dump, const VkPresentTimeGOOGLE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.presentID, "uint32_t", "presentID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.desiredPresentTime, "uint64_t", "desiredPresentTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentTimesInfoGOOGLE(ApiDumpInstance& api_dump, const VkPresentTimesInfoGOOGLE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTimes, object.swapchainCount, "const VkPresentTimeGOOGLE*", "pTimes", "const VkPresentTimeGOOGLE", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentTimeGOOGLE);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.perViewPositionAllComponents, "VkBool32", "perViewPositionAllComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMultiviewPerViewAttributesInfoNVX(ApiDumpInstance& api_dump, const VkMultiviewPerViewAttributesInfoNVX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.perViewAttributes, "VkBool32", "perViewAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.perViewAttributesPositionXOnly, "VkBool32", "perViewAttributesPositionXOnly", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkViewportSwizzleNV(ApiDumpInstance& api_dump, const VkViewportSwizzleNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkViewportCoordinateSwizzleNV(api_dump, object.x, "VkViewportCoordinateSwizzleNV", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkViewportCoordinateSwizzleNV(api_dump, object.y, "VkViewportCoordinateSwizzleNV", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkViewportCoordinateSwizzleNV(api_dump, object.z, "VkViewportCoordinateSwizzleNV", "z", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkViewportCoordinateSwizzleNV(api_dump, object.w, "VkViewportCoordinateSwizzleNV", "w", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportSwizzleStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineViewportSwizzleStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineViewportSwizzleStateCreateFlagsNV(api_dump, object.flags, "VkPipelineViewportSwizzleStateCreateFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewportCount, "uint32_t", "viewportCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pViewportSwizzles, object.viewportCount, "const VkViewportSwizzleNV*", "pViewportSwizzles", "const VkViewportSwizzleNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkViewportSwizzleNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDiscardRectanglePropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDiscardRectanglePropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDiscardRectangles, "uint32_t", "maxDiscardRectangles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineDiscardRectangleStateCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineDiscardRectangleStateCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineDiscardRectangleStateCreateFlagsEXT(api_dump, object.flags, "VkPipelineDiscardRectangleStateCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDiscardRectangleModeEXT(api_dump, object.discardRectangleMode, "VkDiscardRectangleModeEXT", "discardRectangleMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.discardRectangleCount, "uint32_t", "discardRectangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDiscardRectangles, object.discardRectangleCount, "const VkRect2D*", "pDiscardRectangles", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.primitiveOverestimationSize, "float", "primitiveOverestimationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxExtraPrimitiveOverestimationSize, "float", "maxExtraPrimitiveOverestimationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.extraPrimitiveOverestimationSizeGranularity, "float", "extraPrimitiveOverestimationSizeGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveUnderestimation, "VkBool32", "primitiveUnderestimation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.conservativePointAndLineRasterization, "VkBool32", "conservativePointAndLineRasterization", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.degenerateTrianglesRasterized, "VkBool32", "degenerateTrianglesRasterized", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.degenerateLinesRasterized, "VkBool32", "degenerateLinesRasterized", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fullyCoveredFragmentShaderInputVariable, "VkBool32", "fullyCoveredFragmentShaderInputVariable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.conservativeRasterizationPostDepthCoverage, "VkBool32", "conservativeRasterizationPostDepthCoverage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationConservativeStateCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationConservativeStateCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRasterizationConservativeStateCreateFlagsEXT(api_dump, object.flags, "VkPipelineRasterizationConservativeStateCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkConservativeRasterizationModeEXT(api_dump, object.conservativeRasterizationMode, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.extraPrimitiveOverestimationSize, "float", "extraPrimitiveOverestimationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDepthClipEnableFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDepthClipEnableFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClipEnable, "VkBool32", "depthClipEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationDepthClipStateCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationDepthClipStateCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(api_dump, object.flags, "VkPipelineRasterizationDepthClipStateCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClipEnable, "VkBool32", "depthClipEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkXYColorEXT(ApiDumpInstance& api_dump, const VkXYColorEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.x, "float", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.y, "float", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkHdrMetadataEXT(ApiDumpInstance& api_dump, const VkHdrMetadataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkXYColorEXT(api_dump, object.displayPrimaryRed, "VkXYColorEXT", "displayPrimaryRed", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkXYColorEXT(api_dump, object.displayPrimaryGreen, "VkXYColorEXT", "displayPrimaryGreen", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkXYColorEXT(api_dump, object.displayPrimaryBlue, "VkXYColorEXT", "displayPrimaryBlue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkXYColorEXT(api_dump, object.whitePoint, "VkXYColorEXT", "whitePoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxLuminance, "float", "maxLuminance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minLuminance, "float", "minLuminance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxContentLightLevel, "float", "maxContentLightLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxFrameAverageLightLevel, "float", "maxFrameAverageLightLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(ApiDumpInstance& api_dump, const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.relaxedLineRasterization, "VkBool32", "relaxedLineRasterization", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkIOSSurfaceCreateInfoMVK(ApiDumpInstance& api_dump, const VkIOSSurfaceCreateInfoMVK& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIOSSurfaceCreateFlagsMVK(api_dump, object.flags, "VkIOSSurfaceCreateFlagsMVK", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pView, "const void*", "pView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkMacOSSurfaceCreateInfoMVK(ApiDumpInstance& api_dump, const VkMacOSSurfaceCreateInfoMVK& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMacOSSurfaceCreateFlagsMVK(api_dump, object.flags, "VkMacOSSurfaceCreateFlagsMVK", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pView, "const void*", "pView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkDebugUtilsLabelEXT(ApiDumpInstance& api_dump, const VkDebugUtilsLabelEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pLabelName, "const char*", "pLabelName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.color, 4, "float[4]", "color", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugUtilsObjectNameInfoEXT(ApiDumpInstance& api_dump, const VkDebugUtilsObjectNameInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkObjectType(api_dump, object.objectType, "VkObjectType", "objectType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_uint64_t_as_pointer(api_dump, object.objectHandle, "uint64_t", "objectHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pObjectName, "const char*", "pObjectName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugUtilsMessengerCallbackDataEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessengerCallbackDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugUtilsMessengerCallbackDataFlagsEXT(api_dump, object.flags, "VkDebugUtilsMessengerCallbackDataFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pMessageIdName, "const char*", "pMessageIdName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.messageIdNumber, "int32_t", "messageIdNumber", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pMessage, "const char*", "pMessage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueLabelCount, "uint32_t", "queueLabelCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pQueueLabels, object.queueLabelCount, "const VkDebugUtilsLabelEXT*", "pQueueLabels", "const VkDebugUtilsLabelEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsLabelEXT);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cmdBufLabelCount, "uint32_t", "cmdBufLabelCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCmdBufLabels, object.cmdBufLabelCount, "const VkDebugUtilsLabelEXT*", "pCmdBufLabels", "const VkDebugUtilsLabelEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsLabelEXT);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.objectCount, "uint32_t", "objectCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pObjects, object.objectCount, "const VkDebugUtilsObjectNameInfoEXT*", "pObjects", "const VkDebugUtilsObjectNameInfoEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsObjectNameInfoEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugUtilsMessengerCreateInfoEXT(ApiDumpInstance& api_dump, const VkDebugUtilsMessengerCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugUtilsMessengerCreateFlagsEXT(api_dump, object.flags, "VkDebugUtilsMessengerCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugUtilsMessageSeverityFlagsEXT(api_dump, object.messageSeverity, "VkDebugUtilsMessageSeverityFlagsEXT", "messageSeverity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDebugUtilsMessageTypeFlagsEXT(api_dump, object.messageType, "VkDebugUtilsMessageTypeFlagsEXT", "messageType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkDebugUtilsMessengerCallbackEXT(api_dump, object.pfnUserCallback, "PFN_vkDebugUtilsMessengerCallbackEXT", "pfnUserCallback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pUserData, "void*", "pUserData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDebugUtilsObjectTagInfoEXT(ApiDumpInstance& api_dump, const VkDebugUtilsObjectTagInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkObjectType(api_dump, object.objectType, "VkObjectType", "objectType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_uint64_t_as_pointer(api_dump, object.objectHandle, "uint64_t", "objectHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.tagName, "uint64_t", "tagName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tagSize, "size_t", "tagSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pTag, "const void*", "pTag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkAndroidHardwareBufferUsageANDROID(ApiDumpInstance& api_dump, const VkAndroidHardwareBufferUsageANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.androidHardwareBufferUsage, "uint64_t", "androidHardwareBufferUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance& api_dump, const VkAndroidHardwareBufferPropertiesANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.allocationSize, "VkDeviceSize", "allocationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAndroidHardwareBufferFormatPropertiesANDROID(ApiDumpInstance& api_dump, const VkAndroidHardwareBufferFormatPropertiesANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.formatFeatures, "VkFormatFeatureFlags", "formatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.samplerYcbcrConversionComponents, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrModelConversion(api_dump, object.suggestedYcbcrModel, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrRange(api_dump, object.suggestedYcbcrRange, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedXChromaOffset, "VkChromaLocation", "suggestedXChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedYChromaOffset, "VkChromaLocation", "suggestedYChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportAndroidHardwareBufferInfoANDROID(ApiDumpInstance& api_dump, const VkImportAndroidHardwareBufferInfoANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct AHardwareBuffer*>(api_dump, object.buffer, "struct AHardwareBuffer*", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetAndroidHardwareBufferInfoANDROID(ApiDumpInstance& api_dump, const VkMemoryGetAndroidHardwareBufferInfoANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalFormatANDROID(ApiDumpInstance& api_dump, const VkExternalFormatANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAndroidHardwareBufferFormatProperties2ANDROID(ApiDumpInstance& api_dump, const VkAndroidHardwareBufferFormatProperties2ANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.formatFeatures, "VkFormatFeatureFlags2", "formatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.samplerYcbcrConversionComponents, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrModelConversion(api_dump, object.suggestedYcbcrModel, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrRange(api_dump, object.suggestedYcbcrRange, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedXChromaOffset, "VkChromaLocation", "suggestedXChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedYChromaOffset, "VkChromaLocation", "suggestedYChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #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);
+void dump_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderEnqueueFeaturesAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderEnqueue, "VkBool32", "shaderEnqueue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderMeshEnqueue, "VkBool32", "shaderMeshEnqueue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderEnqueuePropertiesAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxExecutionGraphDepth, "uint32_t", "maxExecutionGraphDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxExecutionGraphShaderOutputNodes, "uint32_t", "maxExecutionGraphShaderOutputNodes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxExecutionGraphShaderPayloadSize, "uint32_t", "maxExecutionGraphShaderPayloadSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxExecutionGraphShaderPayloadCount, "uint32_t", "maxExecutionGraphShaderPayloadCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.executionGraphDispatchAddressAlignment, "uint32_t", "executionGraphDispatchAddressAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxExecutionGraphWorkgroupCount, 3, "uint32_t[3]", "maxExecutionGraphWorkgroupCount", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxExecutionGraphWorkgroups, "uint32_t", "maxExecutionGraphWorkgroups", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance& api_dump, const VkExecutionGraphPipelineScratchSizeAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minSize, "VkDeviceSize", "minSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxSize, "VkDeviceSize", "maxSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.sizeGranularity, "VkDeviceSize", "sizeGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExecutionGraphPipelineCreateInfoAMDX(ApiDumpInstance& api_dump, const VkExecutionGraphPipelineCreateInfoAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags(api_dump, object.flags, "VkPipelineCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stageCount, "uint32_t", "stageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStages, object.stageCount, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLibraryInfo, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineLibraryCreateInfoKHR);
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.basePipelineHandle, "VkPipeline", "basePipelineHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.basePipelineIndex, "int32_t", "basePipelineIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceOrHostAddressConstAMDX(ApiDumpInstance& api_dump, const VkDeviceOrHostAddressConstAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.hostAddress, "const void*", "hostAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDispatchGraphInfoAMDX(ApiDumpInstance& api_dump, const VkDispatchGraphInfoAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.nodeIndex, "uint32_t", "nodeIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.payloadCount, "uint32_t", "payloadCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstAMDX(api_dump, object.payloads, "VkDeviceOrHostAddressConstAMDX", "payloads", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.payloadStride, "uint64_t", "payloadStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDispatchGraphCountInfoAMDX(ApiDumpInstance& api_dump, const VkDispatchGraphCountInfoAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.count, "uint32_t", "count", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstAMDX(api_dump, object.infos, "VkDeviceOrHostAddressConstAMDX", "infos", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.stride, "uint64_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineShaderStageNodeCreateInfoAMDX(ApiDumpInstance& api_dump, const VkPipelineShaderStageNodeCreateInfoAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pName, "const char*", "pName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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_VkDeviceAddressRangeEXT(const VkDeviceAddressRangeEXT& object, const ApiDumpSettings& settings, const char* type_name, 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_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_VkDeviceAddressRangeEXT<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_VkDeviceAddressRangeEXT<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_VkDeviceAddressRangeEXT<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, "VkBuildAccelerationStructureFlagsNV", "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_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);
+void dump_VkHostAddressRangeEXT(ApiDumpInstance& api_dump, const VkHostAddressRangeEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<void*>(api_dump, object.address, "void*", "address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.size, "size_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkHostAddressRangeConstEXT(ApiDumpInstance& api_dump, const VkHostAddressRangeConstEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<const void*>(api_dump, object.address, "const void*", "address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.size, "size_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceAddressRangeEXT(ApiDumpInstance& api_dump, const VkDeviceAddressRangeEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.address, "VkDeviceAddress", "address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTexelBufferDescriptorInfoEXT(ApiDumpInstance& api_dump, const VkTexelBufferDescriptorInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceAddressRangeEXT(api_dump, object.addressRange, "VkDeviceAddressRangeEXT", "addressRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageDescriptorInfoEXT(ApiDumpInstance& api_dump, const VkImageDescriptorInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pView, "const VkImageViewCreateInfo*", "pView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageViewCreateInfo);
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.layout, "VkImageLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorViewCreateInfoARM(ApiDumpInstance& api_dump, const VkTensorViewCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorViewCreateFlagsARM(api_dump, object.flags, "VkTensorViewCreateFlagsARM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.tensor, "VkTensorARM", "tensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkResourceDescriptorDataEXT(ApiDumpInstance& api_dump, const VkResourceDescriptorDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) {
+        dump_pointer(api_dump, object.pImage, "const VkImageDescriptorInfoEXT*", "pImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageDescriptorInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
+        dump_pointer(api_dump, object.pTexelBuffer, "const VkTexelBufferDescriptorInfoEXT*", "pTexelBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTexelBufferDescriptorInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV) {
+        dump_pointer(api_dump, object.pAddressRange, "const VkDeviceAddressRangeEXT*", "pAddressRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceAddressRangeEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_TENSOR_ARM) {
+        dump_pointer(api_dump, object.pTensorARM, "const VkTensorViewCreateInfoARM*", "pTensorARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorViewCreateInfoARM);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkResourceDescriptorInfoEXT(ApiDumpInstance& api_dump, const VkResourceDescriptorInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setDescriptorType(object.type);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorType(api_dump, object.type, "VkDescriptorType", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkResourceDescriptorDataEXT(api_dump, object.data, "VkResourceDescriptorDataEXT", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindHeapInfoEXT(ApiDumpInstance& api_dump, const VkBindHeapInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceAddressRangeEXT(api_dump, object.heapRange, "VkDeviceAddressRangeEXT", "heapRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.reservedRangeOffset, "VkDeviceSize", "reservedRangeOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.reservedRangeSize, "VkDeviceSize", "reservedRangeSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPushDataInfoEXT(ApiDumpInstance& api_dump, const VkPushDataInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkHostAddressRangeConstEXT(api_dump, object.data, "VkHostAddressRangeConstEXT", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceConstantOffsetEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceConstantOffsetEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.heapOffset, "uint32_t", "heapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapArrayStride, "uint32_t", "heapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pEmbeddedSampler, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapOffset, "uint32_t", "samplerHeapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapArrayStride, "uint32_t", "samplerHeapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourcePushIndexEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourcePushIndexEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.heapOffset, "uint32_t", "heapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushOffset, "uint32_t", "pushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapIndexStride, "uint32_t", "heapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapArrayStride, "uint32_t", "heapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pEmbeddedSampler, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useCombinedImageSamplerIndex, "VkBool32", "useCombinedImageSamplerIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapOffset, "uint32_t", "samplerHeapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerPushOffset, "uint32_t", "samplerPushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapIndexStride, "uint32_t", "samplerHeapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapArrayStride, "uint32_t", "samplerHeapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceIndirectIndexEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceIndirectIndexEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.heapOffset, "uint32_t", "heapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushOffset, "uint32_t", "pushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.addressOffset, "uint32_t", "addressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapIndexStride, "uint32_t", "heapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapArrayStride, "uint32_t", "heapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pEmbeddedSampler, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useCombinedImageSamplerIndex, "VkBool32", "useCombinedImageSamplerIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapOffset, "uint32_t", "samplerHeapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerPushOffset, "uint32_t", "samplerPushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerAddressOffset, "uint32_t", "samplerAddressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapIndexStride, "uint32_t", "samplerHeapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapArrayStride, "uint32_t", "samplerHeapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceHeapDataEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceHeapDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.heapOffset, "uint32_t", "heapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushOffset, "uint32_t", "pushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceIndirectAddressEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceIndirectAddressEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.pushOffset, "uint32_t", "pushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.addressOffset, "uint32_t", "addressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceShaderRecordIndexEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceShaderRecordIndexEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.heapOffset, "uint32_t", "heapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderRecordOffset, "uint32_t", "shaderRecordOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapIndexStride, "uint32_t", "heapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapArrayStride, "uint32_t", "heapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pEmbeddedSampler, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useCombinedImageSamplerIndex, "VkBool32", "useCombinedImageSamplerIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapOffset, "uint32_t", "samplerHeapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerShaderRecordOffset, "uint32_t", "samplerShaderRecordOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapIndexStride, "uint32_t", "samplerHeapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapArrayStride, "uint32_t", "samplerHeapArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceIndirectIndexArrayEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceIndirectIndexArrayEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.heapOffset, "uint32_t", "heapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushOffset, "uint32_t", "pushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.addressOffset, "uint32_t", "addressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapIndexStride, "uint32_t", "heapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pEmbeddedSampler, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.useCombinedImageSamplerIndex, "VkBool32", "useCombinedImageSamplerIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapOffset, "uint32_t", "samplerHeapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerPushOffset, "uint32_t", "samplerPushOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerAddressOffset, "uint32_t", "samplerAddressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerHeapIndexStride, "uint32_t", "samplerHeapIndexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorMappingSourceDataEXT(ApiDumpInstance& api_dump, const VkDescriptorMappingSourceDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT) {
+        dump_VkDescriptorMappingSourceConstantOffsetEXT(api_dump, object.constantOffset, "VkDescriptorMappingSourceConstantOffsetEXT", "constantOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT) {
+        dump_VkDescriptorMappingSourcePushIndexEXT(api_dump, object.pushIndex, "VkDescriptorMappingSourcePushIndexEXT", "pushIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT) {
+        dump_VkDescriptorMappingSourceIndirectIndexEXT(api_dump, object.indirectIndex, "VkDescriptorMappingSourceIndirectIndexEXT", "indirectIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT) {
+        dump_VkDescriptorMappingSourceIndirectIndexArrayEXT(api_dump, object.indirectIndexArray, "VkDescriptorMappingSourceIndirectIndexArrayEXT", "indirectIndexArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT) {
+        dump_VkDescriptorMappingSourceHeapDataEXT(api_dump, object.heapData, "VkDescriptorMappingSourceHeapDataEXT", "heapData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT) {
+        dump_type<uint32_t>(api_dump, object.pushDataOffset, "uint32_t", "pushDataOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT) {
+        dump_type<uint32_t>(api_dump, object.pushAddressOffset, "uint32_t", "pushAddressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT) {
+        dump_VkDescriptorMappingSourceIndirectAddressEXT(api_dump, object.indirectAddress, "VkDescriptorMappingSourceIndirectAddressEXT", "indirectAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT) {
+        dump_VkDescriptorMappingSourceShaderRecordIndexEXT(api_dump, object.shaderRecordIndex, "VkDescriptorMappingSourceShaderRecordIndexEXT", "shaderRecordIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT) {
+        dump_type<uint32_t>(api_dump, object.shaderRecordDataOffset, "uint32_t", "shaderRecordDataOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT) {
+        dump_type<uint32_t>(api_dump, object.shaderRecordAddressOffset, "uint32_t", "shaderRecordAddressOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetAndBindingMappingEXT(ApiDumpInstance& api_dump, const VkDescriptorSetAndBindingMappingEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setDescriptorMappingSource(object.source);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorSet, "uint32_t", "descriptorSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstBinding, "uint32_t", "firstBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bindingCount, "uint32_t", "bindingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSpirvResourceTypeFlagsEXT(api_dump, object.resourceMask, "VkSpirvResourceTypeFlagsEXT", "resourceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorMappingSourceEXT(api_dump, object.source, "VkDescriptorMappingSourceEXT", "source", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorMappingSourceDataEXT(api_dump, object.sourceData, "VkDescriptorMappingSourceDataEXT", "sourceData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderDescriptorSetAndBindingMappingInfoEXT(ApiDumpInstance& api_dump, const VkShaderDescriptorSetAndBindingMappingInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mappingCount, "uint32_t", "mappingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pMappings, object.mappingCount, "const VkDescriptorSetAndBindingMappingEXT*", "pMappings", "const VkDescriptorSetAndBindingMappingEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetAndBindingMappingEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpaqueCaptureDataCreateInfoEXT(ApiDumpInstance& api_dump, const VkOpaqueCaptureDataCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pData, "const VkHostAddressRangeConstEXT*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkHostAddressRangeConstEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorHeapFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorHeapFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorHeap, "VkBool32", "descriptorHeap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorHeapCaptureReplay, "VkBool32", "descriptorHeapCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorHeapPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorHeapPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.samplerHeapAlignment, "VkDeviceSize", "samplerHeapAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.resourceHeapAlignment, "VkDeviceSize", "resourceHeapAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxSamplerHeapSize, "VkDeviceSize", "maxSamplerHeapSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxResourceHeapSize, "VkDeviceSize", "maxResourceHeapSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minSamplerHeapReservedRange, "VkDeviceSize", "minSamplerHeapReservedRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minSamplerHeapReservedRangeWithEmbedded, "VkDeviceSize", "minSamplerHeapReservedRangeWithEmbedded", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minResourceHeapReservedRange, "VkDeviceSize", "minResourceHeapReservedRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.samplerDescriptorSize, "VkDeviceSize", "samplerDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.imageDescriptorSize, "VkDeviceSize", "imageDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.bufferDescriptorSize, "VkDeviceSize", "bufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.samplerDescriptorAlignment, "VkDeviceSize", "samplerDescriptorAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.imageDescriptorAlignment, "VkDeviceSize", "imageDescriptorAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.bufferDescriptorAlignment, "VkDeviceSize", "bufferDescriptorAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxPushDataSize, "VkDeviceSize", "maxPushDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.imageCaptureReplayOpaqueDataSize, "size_t", "imageCaptureReplayOpaqueDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorHeapEmbeddedSamplers, "uint32_t", "maxDescriptorHeapEmbeddedSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.samplerYcbcrConversionCount, "uint32_t", "samplerYcbcrConversionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseDescriptorHeaps, "VkBool32", "sparseDescriptorHeaps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.protectedDescriptorHeaps, "VkBool32", "protectedDescriptorHeaps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferInheritanceDescriptorHeapInfoEXT(ApiDumpInstance& api_dump, const VkCommandBufferInheritanceDescriptorHeapInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSamplerHeapBindInfo, "const VkBindHeapInfoEXT*", "pSamplerHeapBindInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBindHeapInfoEXT);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pResourceHeapBindInfo, "const VkBindHeapInfoEXT*", "pResourceHeapBindInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBindHeapInfoEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerCustomBorderColorIndexCreateInfoEXT(ApiDumpInstance& api_dump, const VkSamplerCustomBorderColorIndexCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerCustomBorderColorCreateInfoEXT(ApiDumpInstance& api_dump, const VkSamplerCustomBorderColorCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClearColorValue(api_dump, object.customBorderColor, "VkClearColorValue", "customBorderColor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsLayoutPushDataTokenNV(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutPushDataTokenNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushDataOffset, "uint32_t", "pushDataOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushDataSize, "uint32_t", "pushDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubsampledImageFormatPropertiesEXT(ApiDumpInstance& api_dump, const VkSubsampledImageFormatPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subsampledImageDescriptorCount, "uint32_t", "subsampledImageDescriptorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorHeapTensorPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.tensorDescriptorSize, "VkDeviceSize", "tensorDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.tensorDescriptorAlignment, "VkDeviceSize", "tensorDescriptorAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tensorCaptureReplayOpaqueDataSize, "size_t", "tensorCaptureReplayOpaqueDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentSampleCountInfoAMD(ApiDumpInstance& api_dump, const VkAttachmentSampleCountInfoAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachmentSamples, object.colorAttachmentCount, "const VkSampleCountFlagBits*", "pColorAttachmentSamples", "const VkSampleCountFlagBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSampleCountFlagBits);
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.depthStencilAttachmentSamples, "VkSampleCountFlagBits", "depthStencilAttachmentSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSampleLocationEXT(ApiDumpInstance& api_dump, const VkSampleLocationEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.x, "float", "x", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.y, "float", "y", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSampleLocationsInfoEXT(ApiDumpInstance& api_dump, const VkSampleLocationsInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.sampleLocationsPerPixel, "VkSampleCountFlagBits", "sampleLocationsPerPixel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.sampleLocationGridSize, "VkExtent2D", "sampleLocationGridSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sampleLocationsCount, "uint32_t", "sampleLocationsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSampleLocations, object.sampleLocationsCount, "const VkSampleLocationEXT*", "pSampleLocations", "const VkSampleLocationEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSampleLocationEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAttachmentSampleLocationsEXT(ApiDumpInstance& api_dump, const VkAttachmentSampleLocationsEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.attachmentIndex, "uint32_t", "attachmentIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleLocationsInfoEXT(api_dump, object.sampleLocationsInfo, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassSampleLocationsEXT(ApiDumpInstance& api_dump, const VkSubpassSampleLocationsEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.subpassIndex, "uint32_t", "subpassIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleLocationsInfoEXT(api_dump, object.sampleLocationsInfo, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassSampleLocationsBeginInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassSampleLocationsBeginInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentInitialSampleLocationsCount, "uint32_t", "attachmentInitialSampleLocationsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAttachmentInitialSampleLocations, object.attachmentInitialSampleLocationsCount, "const VkAttachmentSampleLocationsEXT*", "pAttachmentInitialSampleLocations", "const VkAttachmentSampleLocationsEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentSampleLocationsEXT);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.postSubpassSampleLocationsCount, "uint32_t", "postSubpassSampleLocationsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPostSubpassSampleLocations, object.postSubpassSampleLocationsCount, "const VkSubpassSampleLocationsEXT*", "pPostSubpassSampleLocations", "const VkSubpassSampleLocationsEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassSampleLocationsEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineSampleLocationsStateCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineSampleLocationsStateCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sampleLocationsEnable, "VkBool32", "sampleLocationsEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleLocationsInfoEXT(api_dump, object.sampleLocationsInfo, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSampleLocationsPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceSampleLocationsPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.sampleLocationSampleCounts, "VkSampleCountFlags", "sampleLocationSampleCounts", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxSampleLocationGridSize, "VkExtent2D", "maxSampleLocationGridSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.sampleLocationCoordinateRange, 2, "float[2]", "sampleLocationCoordinateRange", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sampleLocationSubPixelBits, "uint32_t", "sampleLocationSubPixelBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.variableSampleLocations, "VkBool32", "variableSampleLocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMultisamplePropertiesEXT(ApiDumpInstance& api_dump, const VkMultisamplePropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxSampleLocationGridSize, "VkExtent2D", "maxSampleLocationGridSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.advancedBlendCoherentOperations, "VkBool32", "advancedBlendCoherentOperations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.advancedBlendMaxColorAttachments, "uint32_t", "advancedBlendMaxColorAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.advancedBlendIndependentBlend, "VkBool32", "advancedBlendIndependentBlend", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.advancedBlendNonPremultipliedSrcColor, "VkBool32", "advancedBlendNonPremultipliedSrcColor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.advancedBlendNonPremultipliedDstColor, "VkBool32", "advancedBlendNonPremultipliedDstColor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.advancedBlendCorrelatedOverlap, "VkBool32", "advancedBlendCorrelatedOverlap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.advancedBlendAllOperations, "VkBool32", "advancedBlendAllOperations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineColorBlendAdvancedStateCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineColorBlendAdvancedStateCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.srcPremultiplied, "VkBool32", "srcPremultiplied", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dstPremultiplied, "VkBool32", "dstPremultiplied", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendOverlapEXT(api_dump, object.blendOverlap, "VkBlendOverlapEXT", "blendOverlap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCoverageToColorStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineCoverageToColorStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCoverageToColorStateCreateFlagsNV(api_dump, object.flags, "VkPipelineCoverageToColorStateCreateFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.coverageToColorEnable, "VkBool32", "coverageToColorEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.coverageToColorLocation, "uint32_t", "coverageToColorLocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCoverageModulationStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineCoverageModulationStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCoverageModulationStateCreateFlagsNV(api_dump, object.flags, "VkPipelineCoverageModulationStateCreateFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCoverageModulationModeNV(api_dump, object.coverageModulationMode, "VkCoverageModulationModeNV", "coverageModulationMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.coverageModulationTableEnable, "VkBool32", "coverageModulationTableEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.coverageModulationTableCount, "uint32_t", "coverageModulationTableCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCoverageModulationTable, object.coverageModulationTableCount, "const float*", "pCoverageModulationTable", "const float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const float>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderSMCount, "uint32_t", "shaderSMCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderWarpsPerSM, "uint32_t", "shaderWarpsPerSM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSMBuiltins, "VkBool32", "shaderSMBuiltins", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrmFormatModifierPropertiesEXT(ApiDumpInstance& api_dump, const VkDrmFormatModifierPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint64_t>(api_dump, object.drmFormatModifier, "uint64_t", "drmFormatModifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.drmFormatModifierPlaneCount, "uint32_t", "drmFormatModifierPlaneCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.drmFormatModifierTilingFeatures, "VkFormatFeatureFlags", "drmFormatModifierTilingFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrmFormatModifierPropertiesListEXT(ApiDumpInstance& api_dump, const VkDrmFormatModifierPropertiesListEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.drmFormatModifierCount, "uint32_t", "drmFormatModifierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDrmFormatModifierProperties, object.drmFormatModifierCount, "VkDrmFormatModifierPropertiesEXT*", "pDrmFormatModifierProperties", "VkDrmFormatModifierPropertiesEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDrmFormatModifierPropertiesEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.drmFormatModifier, "uint64_t", "drmFormatModifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSharingMode(api_dump, object.sharingMode, "VkSharingMode", "sharingMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndexCount, "uint32_t", "queueFamilyIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pQueueFamilyIndices, object.queueFamilyIndexCount, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageDrmFormatModifierListCreateInfoEXT(ApiDumpInstance& api_dump, const VkImageDrmFormatModifierListCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.drmFormatModifierCount, "uint32_t", "drmFormatModifierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDrmFormatModifiers, object.drmFormatModifierCount, "const uint64_t*", "pDrmFormatModifiers", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageDrmFormatModifierExplicitCreateInfoEXT(ApiDumpInstance& api_dump, const VkImageDrmFormatModifierExplicitCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.drmFormatModifier, "uint64_t", "drmFormatModifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.drmFormatModifierPlaneCount, "uint32_t", "drmFormatModifierPlaneCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPlaneLayouts, object.drmFormatModifierPlaneCount, "const VkSubresourceLayout*", "pPlaneLayouts", "const VkSubresourceLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSubresourceLayout);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageDrmFormatModifierPropertiesEXT(ApiDumpInstance& api_dump, const VkImageDrmFormatModifierPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.drmFormatModifier, "uint64_t", "drmFormatModifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrmFormatModifierProperties2EXT(ApiDumpInstance& api_dump, const VkDrmFormatModifierProperties2EXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint64_t>(api_dump, object.drmFormatModifier, "uint64_t", "drmFormatModifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.drmFormatModifierPlaneCount, "uint32_t", "drmFormatModifierPlaneCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.drmFormatModifierTilingFeatures, "VkFormatFeatureFlags2", "drmFormatModifierTilingFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrmFormatModifierPropertiesList2EXT(ApiDumpInstance& api_dump, const VkDrmFormatModifierPropertiesList2EXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.drmFormatModifierCount, "uint32_t", "drmFormatModifierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDrmFormatModifierProperties, object.drmFormatModifierCount, "VkDrmFormatModifierProperties2EXT*", "pDrmFormatModifierProperties", "VkDrmFormatModifierProperties2EXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDrmFormatModifierProperties2EXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkValidationCacheCreateInfoEXT(ApiDumpInstance& api_dump, const VkValidationCacheCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkValidationCacheCreateFlagsEXT(api_dump, object.flags, "VkValidationCacheCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.initialDataSize, "size_t", "initialDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pInitialData, "const void*", "pInitialData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderModuleValidationCacheCreateInfoEXT(ApiDumpInstance& api_dump, const VkShaderModuleValidationCacheCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkValidationCacheEXT(api_dump, object.validationCache, "VkValidationCacheEXT", "validationCache", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShadingRatePaletteNV(ApiDumpInstance& api_dump, const VkShadingRatePaletteNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.shadingRatePaletteEntryCount, "uint32_t", "shadingRatePaletteEntryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pShadingRatePaletteEntries, object.shadingRatePaletteEntryCount, "const VkShadingRatePaletteEntryNV*", "pShadingRatePaletteEntries", "const VkShadingRatePaletteEntryNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkShadingRatePaletteEntryNV);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportShadingRateImageStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineViewportShadingRateImageStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shadingRateImageEnable, "VkBool32", "shadingRateImageEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewportCount, "uint32_t", "viewportCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pShadingRatePalettes, object.viewportCount, "const VkShadingRatePaletteNV*", "pShadingRatePalettes", "const VkShadingRatePaletteNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkShadingRatePaletteNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShadingRateImageFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceShadingRateImageFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shadingRateImage, "VkBool32", "shadingRateImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shadingRateCoarseSampleOrder, "VkBool32", "shadingRateCoarseSampleOrder", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShadingRateImagePropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceShadingRateImagePropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.shadingRateTexelSize, "VkExtent2D", "shadingRateTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shadingRatePaletteSize, "uint32_t", "shadingRatePaletteSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shadingRateMaxCoarseSamples, "uint32_t", "shadingRateMaxCoarseSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCoarseSampleLocationNV(ApiDumpInstance& api_dump, const VkCoarseSampleLocationNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.pixelX, "uint32_t", "pixelX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pixelY, "uint32_t", "pixelY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sample, "uint32_t", "sample", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCoarseSampleOrderCustomNV(ApiDumpInstance& api_dump, const VkCoarseSampleOrderCustomNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkShadingRatePaletteEntryNV(api_dump, object.shadingRate, "VkShadingRatePaletteEntryNV", "shadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sampleCount, "uint32_t", "sampleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sampleLocationCount, "uint32_t", "sampleLocationCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSampleLocations, object.sampleLocationCount, "const VkCoarseSampleLocationNV*", "pSampleLocations", "const VkCoarseSampleLocationNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkCoarseSampleLocationNV);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCoarseSampleOrderTypeNV(api_dump, object.sampleOrderType, "VkCoarseSampleOrderTypeNV", "sampleOrderType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.customSampleOrderCount, "uint32_t", "customSampleOrderCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pCustomSampleOrders, object.customSampleOrderCount, "const VkCoarseSampleOrderCustomNV*", "pCustomSampleOrders", "const VkCoarseSampleOrderCustomNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkCoarseSampleOrderCustomNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRayTracingShaderGroupCreateInfoNV(ApiDumpInstance& api_dump, const VkRayTracingShaderGroupCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRayTracingShaderGroupTypeKHR(api_dump, object.type, "VkRayTracingShaderGroupTypeKHR", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.generalShader, "uint32_t", "generalShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.closestHitShader, "uint32_t", "closestHitShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.anyHitShader, "uint32_t", "anyHitShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intersectionShader, "uint32_t", "intersectionShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRayTracingPipelineCreateInfoNV(ApiDumpInstance& api_dump, const VkRayTracingPipelineCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags(api_dump, object.flags, "VkPipelineCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stageCount, "uint32_t", "stageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStages, object.stageCount, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.groupCount, "uint32_t", "groupCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pGroups, object.groupCount, "const VkRayTracingShaderGroupCreateInfoNV*", "pGroups", "const VkRayTracingShaderGroupCreateInfoNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingShaderGroupCreateInfoNV);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRecursionDepth, "uint32_t", "maxRecursionDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.basePipelineHandle, "VkPipeline", "basePipelineHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.basePipelineIndex, "int32_t", "basePipelineIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeometryTrianglesNV(ApiDumpInstance& api_dump, const VkGeometryTrianglesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.vertexData, "VkBuffer", "vertexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.vertexOffset, "VkDeviceSize", "vertexOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexCount, "uint32_t", "vertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.vertexStride, "VkDeviceSize", "vertexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.vertexFormat, "VkFormat", "vertexFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.indexData, "VkBuffer", "indexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indexOffset, "VkDeviceSize", "indexOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.indexCount, "uint32_t", "indexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.transformData, "VkBuffer", "transformData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.transformOffset, "VkDeviceSize", "transformOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeometryAABBNV(ApiDumpInstance& api_dump, const VkGeometryAABBNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.aabbData, "VkBuffer", "aabbData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numAABBs, "uint32_t", "numAABBs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stride, "uint32_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeometryDataNV(ApiDumpInstance& api_dump, const VkGeometryDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkGeometryTrianglesNV(api_dump, object.triangles, "VkGeometryTrianglesNV", "triangles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryAABBNV(api_dump, object.aabbs, "VkGeometryAABBNV", "aabbs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeometryNV(ApiDumpInstance& api_dump, const VkGeometryNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryTypeKHR(api_dump, object.geometryType, "VkGeometryTypeKHR", "geometryType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryDataNV(api_dump, object.geometry, "VkGeometryDataNV", "geometry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryFlagsKHR(api_dump, object.flags, "VkGeometryFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureInfoNV(ApiDumpInstance& api_dump, const VkAccelerationStructureInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureTypeKHR(api_dump, object.type, "VkAccelerationStructureTypeNV", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildAccelerationStructureFlagsKHR(api_dump, object.flags, "VkBuildAccelerationStructureFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCount, "uint32_t", "instanceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.geometryCount, "uint32_t", "geometryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pGeometries, object.geometryCount, "const VkGeometryNV*", "pGeometries", "const VkGeometryNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkGeometryNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureCreateInfoNV(ApiDumpInstance& api_dump, const VkAccelerationStructureCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.compactedSize, "VkDeviceSize", "compactedSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureInfoNV(api_dump, object.info, "VkAccelerationStructureInfoNV", "info", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindAccelerationStructureMemoryInfoNV(ApiDumpInstance& api_dump, const VkBindAccelerationStructureMemoryInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureNV(api_dump, object.accelerationStructure, "VkAccelerationStructureNV", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceIndexCount, "uint32_t", "deviceIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDeviceIndices, object.deviceIndexCount, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteDescriptorSetAccelerationStructureNV(ApiDumpInstance& api_dump, const VkWriteDescriptorSetAccelerationStructureNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.accelerationStructureCount, "uint32_t", "accelerationStructureCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAccelerationStructures, object.accelerationStructureCount, "const VkAccelerationStructureNV*", "pAccelerationStructures", "const VkAccelerationStructureNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureMemoryRequirementsInfoNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMemoryRequirementsInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureMemoryRequirementsTypeNV(api_dump, object.type, "VkAccelerationStructureMemoryRequirementsTypeNV", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureNV(api_dump, object.accelerationStructure, "VkAccelerationStructureNV", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderGroupHandleSize, "uint32_t", "shaderGroupHandleSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRecursionDepth, "uint32_t", "maxRecursionDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxShaderGroupStride, "uint32_t", "maxShaderGroupStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderGroupBaseAlignment, "uint32_t", "shaderGroupBaseAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxGeometryCount, "uint64_t", "maxGeometryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxInstanceCount, "uint64_t", "maxInstanceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxTriangleCount, "uint64_t", "maxTriangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetAccelerationStructures, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTransformMatrixKHR(ApiDumpInstance& api_dump, const VkTransformMatrixKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_double_array(api_dump, object.matrix, 3, 4, "float[3][4]", "matrix", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAabbPositionsKHR(ApiDumpInstance& api_dump, const VkAabbPositionsKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.minX, "float", "minX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minY, "float", "minY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minZ, "float", "minZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxX, "float", "maxX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxY, "float", "maxY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxZ, "float", "maxZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureInstanceKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureInstanceKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkTransformMatrixKHR(api_dump, object.transform, "VkTransformMatrixKHR", "transform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCustomIndex, "uint32_t:24", "instanceCustomIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mask, "uint32_t:8", "mask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceShaderBindingTableRecordOffset, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryInstanceFlagsKHR(api_dump, object.flags, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.accelerationStructureReference, "uint64_t", "accelerationStructureReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.representativeFragmentTest, "VkBool32", "representativeFragmentTest", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineRepresentativeFragmentTestStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.representativeFragmentTestEnable, "VkBool32", "representativeFragmentTestEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageViewImageFormatInfoEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageViewImageFormatInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageViewType(api_dump, object.imageViewType, "VkImageViewType", "imageViewType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFilterCubicImageViewImageFormatPropertiesEXT(ApiDumpInstance& api_dump, const VkFilterCubicImageViewImageFormatPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filterCubic, "VkBool32", "filterCubic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.filterCubicMinmax, "VkBool32", "filterCubicMinmax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixConversion, "VkBool32", "cooperativeMatrixConversion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportMemoryHostPointerInfoEXT(ApiDumpInstance& api_dump, const VkImportMemoryHostPointerInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pHostPointer, "void*", "pHostPointer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryHostPointerPropertiesEXT(ApiDumpInstance& api_dump, const VkMemoryHostPointerPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minImportedHostPointerAlignment, "VkDeviceSize", "minImportedHostPointerAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCompilerControlCreateInfoAMD(ApiDumpInstance& api_dump, const VkPipelineCompilerControlCreateInfoAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCompilerControlFlagsAMD(api_dump, object.compilerControlFlags, "VkPipelineCompilerControlFlagsAMD", "compilerControlFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderCorePropertiesAMD(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderCorePropertiesAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderEngineCount, "uint32_t", "shaderEngineCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderArraysPerEngineCount, "uint32_t", "shaderArraysPerEngineCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.computeUnitsPerShaderArray, "uint32_t", "computeUnitsPerShaderArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.simdPerComputeUnit, "uint32_t", "simdPerComputeUnit", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.wavefrontsPerSimd, "uint32_t", "wavefrontsPerSimd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.wavefrontSize, "uint32_t", "wavefrontSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sgprsPerSimd, "uint32_t", "sgprsPerSimd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minSgprAllocation, "uint32_t", "minSgprAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSgprAllocation, "uint32_t", "maxSgprAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sgprAllocationGranularity, "uint32_t", "sgprAllocationGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vgprsPerSimd, "uint32_t", "vgprsPerSimd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minVgprAllocation, "uint32_t", "minVgprAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVgprAllocation, "uint32_t", "maxVgprAllocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vgprAllocationGranularity, "uint32_t", "vgprAllocationGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceMemoryOverallocationCreateInfoAMD(ApiDumpInstance& api_dump, const VkDeviceMemoryOverallocationCreateInfoAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryOverallocationBehaviorAMD(api_dump, object.overallocationBehavior, "VkMemoryOverallocationBehaviorAMD", "overallocationBehavior", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertexAttribDivisor, "uint32_t", "maxVertexAttribDivisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPresentFrameTokenGGP(ApiDumpInstance& api_dump, const VkPresentFrameTokenGGP& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<GgpFrameToken>(api_dump, object.frameToken, "GgpFrameToken", "frameToken", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceMeshShaderFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceMeshShaderFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.taskShader, "VkBool32", "taskShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.meshShader, "VkBool32", "meshShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMeshShaderPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceMeshShaderPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDrawMeshTasksCount, "uint32_t", "maxDrawMeshTasksCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskWorkGroupInvocations, "uint32_t", "maxTaskWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxTaskWorkGroupSize, 3, "uint32_t[3]", "maxTaskWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskTotalMemorySize, "uint32_t", "maxTaskTotalMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskOutputCount, "uint32_t", "maxTaskOutputCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshWorkGroupInvocations, "uint32_t", "maxMeshWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxMeshWorkGroupSize, 3, "uint32_t[3]", "maxMeshWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshTotalMemorySize, "uint32_t", "maxMeshTotalMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputVertices, "uint32_t", "maxMeshOutputVertices", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputPrimitives, "uint32_t", "maxMeshOutputPrimitives", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshMultiviewViewCount, "uint32_t", "maxMeshMultiviewViewCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.meshOutputPerVertexGranularity, "uint32_t", "meshOutputPerVertexGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.meshOutputPerPrimitiveGranularity, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrawMeshTasksIndirectCommandNV(ApiDumpInstance& api_dump, const VkDrawMeshTasksIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.taskCount, "uint32_t", "taskCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstTask, "uint32_t", "firstTask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderImageFootprintFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderImageFootprintFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageFootprint, "VkBool32", "imageFootprint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportExclusiveScissorStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineViewportExclusiveScissorStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.exclusiveScissorCount, "uint32_t", "exclusiveScissorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pExclusiveScissors, object.exclusiveScissorCount, "const VkRect2D*", "pExclusiveScissors", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExclusiveScissorFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceExclusiveScissorFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.exclusiveScissor, "VkBool32", "exclusiveScissor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyCheckpointPropertiesNV(ApiDumpInstance& api_dump, const VkQueueFamilyCheckpointPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags(api_dump, object.checkpointExecutionStageMask, "VkPipelineStageFlags", "checkpointExecutionStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCheckpointDataNV(ApiDumpInstance& api_dump, const VkCheckpointDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlagBits(api_dump, object.stage, "VkPipelineStageFlagBits", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pCheckpointMarker, "void*", "pCheckpointMarker", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyCheckpointProperties2NV(ApiDumpInstance& api_dump, const VkQueueFamilyCheckpointProperties2NV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.checkpointExecutionStageMask, "VkPipelineStageFlags2", "checkpointExecutionStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCheckpointData2NV(ApiDumpInstance& api_dump, const VkCheckpointData2NV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.stage, "VkPipelineStageFlags2", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pCheckpointMarker, "void*", "pCheckpointMarker", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentTimingFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentTimingFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentTiming, "VkBool32", "presentTiming", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentAtAbsoluteTime, "VkBool32", "presentAtAbsoluteTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentAtRelativeTime, "VkBool32", "presentAtRelativeTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentTimingSurfaceCapabilitiesEXT(ApiDumpInstance& api_dump, const VkPresentTimingSurfaceCapabilitiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentTimingSupported, "VkBool32", "presentTimingSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentAtAbsoluteTimeSupported, "VkBool32", "presentAtAbsoluteTimeSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentAtRelativeTimeSupported, "VkBool32", "presentAtRelativeTimeSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentStageFlagsEXT(api_dump, object.presentStageQueries, "VkPresentStageFlagsEXT", "presentStageQueries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainCalibratedTimestampInfoEXT(ApiDumpInstance& api_dump, const VkSwapchainCalibratedTimestampInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.swapchain, "VkSwapchainKHR", "swapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentStageFlagsEXT(api_dump, object.presentStage, "VkPresentStageFlagsEXT", "presentStage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeDomainId, "uint64_t", "timeDomainId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainTimingPropertiesEXT(ApiDumpInstance& api_dump, const VkSwapchainTimingPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.refreshDuration, "uint64_t", "refreshDuration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.refreshInterval, "uint64_t", "refreshInterval", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainTimeDomainPropertiesEXT(ApiDumpInstance& api_dump, const VkSwapchainTimeDomainPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.timeDomainCount, "uint32_t", "timeDomainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTimeDomains, object.timeDomainCount, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTimeDomainKHR);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTimeDomainIds, object.timeDomainCount, "uint64_t*", "pTimeDomainIds", "uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPastPresentationTimingInfoEXT(ApiDumpInstance& api_dump, const VkPastPresentationTimingInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPastPresentationTimingFlagsEXT(api_dump, object.flags, "VkPastPresentationTimingFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSwapchainKHR(api_dump, object.swapchain, "VkSwapchainKHR", "swapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentStageTimeEXT(ApiDumpInstance& api_dump, const VkPresentStageTimeEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPresentStageFlagsEXT(api_dump, object.stage, "VkPresentStageFlagsEXT", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.time, "uint64_t", "time", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPastPresentationTimingEXT(ApiDumpInstance& api_dump, const VkPastPresentationTimingEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentId, "uint64_t", "presentId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.targetTime, "uint64_t", "targetTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.presentStageCount, "uint32_t", "presentStageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentStages, object.presentStageCount, "VkPresentStageTimeEXT*", "pPresentStages", "VkPresentStageTimeEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentStageTimeEXT);
+    dump_separate_members(api_dump);
+    dump_VkTimeDomainKHR(api_dump, object.timeDomain, "VkTimeDomainKHR", "timeDomain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeDomainId, "uint64_t", "timeDomainId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.reportComplete, "VkBool32", "reportComplete", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPastPresentationTimingPropertiesEXT(ApiDumpInstance& api_dump, const VkPastPresentationTimingPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timingPropertiesCounter, "uint64_t", "timingPropertiesCounter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeDomainsCounter, "uint64_t", "timeDomainsCounter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.presentationTimingCount, "uint32_t", "presentationTimingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentationTimings, object.presentationTimingCount, "VkPastPresentationTimingEXT*", "pPresentationTimings", "VkPastPresentationTimingEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPastPresentationTimingEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentTimingInfoEXT(ApiDumpInstance& api_dump, const VkPresentTimingInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentTimingInfoFlagsEXT(api_dump, object.flags, "VkPresentTimingInfoFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.targetTime, "uint64_t", "targetTime", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.timeDomainId, "uint64_t", "timeDomainId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentStageFlagsEXT(api_dump, object.presentStageQueries, "VkPresentStageFlagsEXT", "presentStageQueries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPresentStageFlagsEXT(api_dump, object.targetTimeDomainPresentStage, "VkPresentStageFlagsEXT", "targetTimeDomainPresentStage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPresentTimingsInfoEXT(ApiDumpInstance& api_dump, const VkPresentTimingsInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.swapchainCount, "uint32_t", "swapchainCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTimingInfos, object.swapchainCount, "const VkPresentTimingInfoEXT*", "pTimingInfos", "const VkPresentTimingInfoEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentTimingInfoEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderIntegerFunctions2, "VkBool32", "shaderIntegerFunctions2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceValueDataINTEL(ApiDumpInstance& api_dump, const VkPerformanceValueDataINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.value32, "uint32_t", "value32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.value64, "uint64_t", "value64", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.valueFloat, "float", "valueFloat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.valueBool, "VkBool32", "valueBool", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.valueString, "const char*", "valueString", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceValueINTEL(ApiDumpInstance& api_dump, const VkPerformanceValueINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPerformanceValueTypeINTEL(api_dump, object.type, "VkPerformanceValueTypeINTEL", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceValueDataINTEL(api_dump, object.data, "VkPerformanceValueDataINTEL", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkInitializePerformanceApiInfoINTEL(ApiDumpInstance& api_dump, const VkInitializePerformanceApiInfoINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pUserData, "void*", "pUserData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueryPoolPerformanceQueryCreateInfoINTEL(ApiDumpInstance& api_dump, const VkQueryPoolPerformanceQueryCreateInfoINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueryPoolSamplingModeINTEL(api_dump, object.performanceCountersSampling, "VkQueryPoolSamplingModeINTEL", "performanceCountersSampling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceMarkerInfoINTEL(ApiDumpInstance& api_dump, const VkPerformanceMarkerInfoINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.marker, "uint64_t", "marker", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceStreamMarkerInfoINTEL(ApiDumpInstance& api_dump, const VkPerformanceStreamMarkerInfoINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.marker, "uint32_t", "marker", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceOverrideInfoINTEL(ApiDumpInstance& api_dump, const VkPerformanceOverrideInfoINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceOverrideTypeINTEL(api_dump, object.type, "VkPerformanceOverrideTypeINTEL", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.enable, "VkBool32", "enable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.parameter, "uint64_t", "parameter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceConfigurationAcquireInfoINTEL(ApiDumpInstance& api_dump, const VkPerformanceConfigurationAcquireInfoINTEL& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceConfigurationTypeINTEL(api_dump, object.type, "VkPerformanceConfigurationTypeINTEL", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePCIBusInfoPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePCIBusInfoPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pciDomain, "uint32_t", "pciDomain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pciBus, "uint32_t", "pciBus", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pciDevice, "uint32_t", "pciDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pciFunction, "uint32_t", "pciFunction", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayNativeHdrSurfaceCapabilitiesAMD(ApiDumpInstance& api_dump, const VkDisplayNativeHdrSurfaceCapabilitiesAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.localDimmingSupport, "VkBool32", "localDimmingSupport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainDisplayNativeHdrCreateInfoAMD(ApiDumpInstance& api_dump, const VkSwapchainDisplayNativeHdrCreateInfoAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.localDimmingEnable, "VkBool32", "localDimmingEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImagePipeSurfaceCreateInfoFUCHSIA(ApiDumpInstance& api_dump, const VkImagePipeSurfaceCreateInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImagePipeSurfaceCreateFlagsFUCHSIA(api_dump, object.flags, "VkImagePipeSurfaceCreateFlagsFUCHSIA", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<zx_handle_t>(api_dump, object.imagePipeHandle, "zx_handle_t", "imagePipeHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkMetalSurfaceCreateInfoEXT(ApiDumpInstance& api_dump, const VkMetalSurfaceCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMetalSurfaceCreateFlagsEXT(api_dump, object.flags, "VkMetalSurfaceCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const CAMetalLayer*>(api_dump, object.pLayer, "const CAMetalLayer*", "pLayer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityMap, "VkBool32", "fragmentDensityMap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityMapDynamic, "VkBool32", "fragmentDensityMapDynamic", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityMapNonSubsampledImages, "VkBool32", "fragmentDensityMapNonSubsampledImages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.minFragmentDensityTexelSize, "VkExtent2D", "minFragmentDensityTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxFragmentDensityTexelSize, "VkExtent2D", "maxFragmentDensityTexelSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityInvocations, "VkBool32", "fragmentDensityInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassFragmentDensityMapCreateInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassFragmentDensityMapCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAttachmentReference(api_dump, object.fragmentDensityMapAttachment, "VkAttachmentReference", "fragmentDensityMapAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderingFragmentDensityMapAttachmentInfoEXT(ApiDumpInstance& api_dump, const VkRenderingFragmentDensityMapAttachmentInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageLayout(api_dump, object.imageLayout, "VkImageLayout", "imageLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderCoreProperties2AMD(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderCoreProperties2AMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderCorePropertiesFlagsAMD(api_dump, object.shaderCoreFeatures, "VkShaderCorePropertiesFlagsAMD", "shaderCoreFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.activeComputeUnitCount, "uint32_t", "activeComputeUnitCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCoherentMemoryFeaturesAMD(ApiDumpInstance& api_dump, const VkPhysicalDeviceCoherentMemoryFeaturesAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceCoherentMemory, "VkBool32", "deviceCoherentMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderImageInt64Atomics, "VkBool32", "shaderImageInt64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseImageInt64Atomics, "VkBool32", "sparseImageInt64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMemoryBudgetPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMemoryBudgetPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.heapBudget, std::min(api_dump.getMemoryHeapCount(), VK_MAX_MEMORY_HEAPS), "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "heapBudget", "VkDeviceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<VkDeviceSize>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.heapUsage, std::min(api_dump.getMemoryHeapCount(), VK_MAX_MEMORY_HEAPS), "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "heapUsage", "VkDeviceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<VkDeviceSize>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMemoryPriorityFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMemoryPriorityFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.memoryPriority, "VkBool32", "memoryPriority", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryPriorityAllocateInfoEXT(ApiDumpInstance& api_dump, const VkMemoryPriorityAllocateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.priority, "float", "priority", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dedicatedAllocationImageAliasing, "VkBool32", "dedicatedAllocationImageAliasing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddress, "VkBool32", "bufferDeviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddressCaptureReplay, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferDeviceAddressMultiDevice, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferDeviceAddressCreateInfoEXT(ApiDumpInstance& api_dump, const VkBufferDeviceAddressCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkValidationFeaturesEXT(ApiDumpInstance& api_dump, const VkValidationFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.enabledValidationFeatureCount, "uint32_t", "enabledValidationFeatureCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pEnabledValidationFeatures, object.enabledValidationFeatureCount, "const VkValidationFeatureEnableEXT*", "pEnabledValidationFeatures", "const VkValidationFeatureEnableEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationFeatureEnableEXT);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.disabledValidationFeatureCount, "uint32_t", "disabledValidationFeatureCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDisabledValidationFeatures, object.disabledValidationFeatureCount, "const VkValidationFeatureDisableEXT*", "pDisabledValidationFeatures", "const VkValidationFeatureDisableEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationFeatureDisableEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCooperativeMatrixPropertiesNV(ApiDumpInstance& api_dump, const VkCooperativeMatrixPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.MSize, "uint32_t", "MSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.NSize, "uint32_t", "NSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.KSize, "uint32_t", "KSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.AType, "VkComponentTypeNV", "AType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.BType, "VkComponentTypeNV", "BType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.CType, "VkComponentTypeNV", "CType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.DType, "VkComponentTypeNV", "DType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkScopeKHR(api_dump, object.scope, "VkScopeNV", "scope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrixFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrixFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrix, "VkBool32", "cooperativeMatrix", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixRobustBufferAccess, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrixPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.cooperativeMatrixSupportedStages, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCoverageReductionModeFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCoverageReductionModeFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.coverageReductionMode, "VkBool32", "coverageReductionMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCoverageReductionStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineCoverageReductionStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCoverageReductionStateCreateFlagsNV(api_dump, object.flags, "VkPipelineCoverageReductionStateCreateFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCoverageReductionModeNV(api_dump, object.coverageReductionMode, "VkCoverageReductionModeNV", "coverageReductionMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFramebufferMixedSamplesCombinationNV(ApiDumpInstance& api_dump, const VkFramebufferMixedSamplesCombinationNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCoverageReductionModeNV(api_dump, object.coverageReductionMode, "VkCoverageReductionModeNV", "coverageReductionMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.rasterizationSamples, "VkSampleCountFlagBits", "rasterizationSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.depthStencilSamples, "VkSampleCountFlags", "depthStencilSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlags(api_dump, object.colorSamples, "VkSampleCountFlags", "colorSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShaderSampleInterlock, "VkBool32", "fragmentShaderSampleInterlock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShaderPixelInterlock, "VkBool32", "fragmentShaderPixelInterlock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShaderShadingRateInterlock, "VkBool32", "fragmentShaderShadingRateInterlock", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.ycbcrImageArrays, "VkBool32", "ycbcrImageArrays", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceProvokingVertexFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceProvokingVertexFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.provokingVertexLast, "VkBool32", "provokingVertexLast", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedbackPreservesProvokingVertex, "VkBool32", "transformFeedbackPreservesProvokingVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceProvokingVertexPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceProvokingVertexPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.provokingVertexModePerPipeline, "VkBool32", "provokingVertexModePerPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transformFeedbackPreservesTriangleFanProvokingVertex, "VkBool32", "transformFeedbackPreservesTriangleFanProvokingVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkProvokingVertexModeEXT(api_dump, object.provokingVertexMode, "VkProvokingVertexModeEXT", "provokingVertexMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkSurfaceFullScreenExclusiveInfoEXT(ApiDumpInstance& api_dump, const VkSurfaceFullScreenExclusiveInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFullScreenExclusiveEXT(api_dump, object.fullScreenExclusive, "VkFullScreenExclusiveEXT", "fullScreenExclusive", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilitiesFullScreenExclusiveEXT(ApiDumpInstance& api_dump, const VkSurfaceCapabilitiesFullScreenExclusiveEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fullScreenExclusiveSupported, "VkBool32", "fullScreenExclusiveSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceFullScreenExclusiveWin32InfoEXT(ApiDumpInstance& api_dump, const VkSurfaceFullScreenExclusiveWin32InfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<HMONITOR>(api_dump, object.hmonitor, "HMONITOR", "hmonitor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkHeadlessSurfaceCreateInfoEXT(ApiDumpInstance& api_dump, const VkHeadlessSurfaceCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkHeadlessSurfaceCreateFlagsEXT(api_dump, object.flags, "VkHeadlessSurfaceCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat32Atomics, "VkBool32", "shaderBufferFloat32Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat32AtomicAdd, "VkBool32", "shaderBufferFloat32AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat64Atomics, "VkBool32", "shaderBufferFloat64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat64AtomicAdd, "VkBool32", "shaderBufferFloat64AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat32Atomics, "VkBool32", "shaderSharedFloat32Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat32AtomicAdd, "VkBool32", "shaderSharedFloat32AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat64Atomics, "VkBool32", "shaderSharedFloat64Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat64AtomicAdd, "VkBool32", "shaderSharedFloat64AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderImageFloat32Atomics, "VkBool32", "shaderImageFloat32Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderImageFloat32AtomicAdd, "VkBool32", "shaderImageFloat32AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseImageFloat32Atomics, "VkBool32", "sparseImageFloat32Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseImageFloat32AtomicAdd, "VkBool32", "sparseImageFloat32AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState, "VkBool32", "extendedDynamicState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.memoryMapPlaced, "VkBool32", "memoryMapPlaced", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.memoryMapRangePlaced, "VkBool32", "memoryMapRangePlaced", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.memoryUnmapReserve, "VkBool32", "memoryUnmapReserve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.minPlacedMemoryMapAlignment, "VkDeviceSize", "minPlacedMemoryMapAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryMapPlacedInfoEXT(ApiDumpInstance& api_dump, const VkMemoryMapPlacedInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pPlacedAddress, "void*", "pPlacedAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat16Atomics, "VkBool32", "shaderBufferFloat16Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat16AtomicAdd, "VkBool32", "shaderBufferFloat16AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat16AtomicMinMax, "VkBool32", "shaderBufferFloat16AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat32AtomicMinMax, "VkBool32", "shaderBufferFloat32AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderBufferFloat64AtomicMinMax, "VkBool32", "shaderBufferFloat64AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat16Atomics, "VkBool32", "shaderSharedFloat16Atomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat16AtomicAdd, "VkBool32", "shaderSharedFloat16AtomicAdd", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat16AtomicMinMax, "VkBool32", "shaderSharedFloat16AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat32AtomicMinMax, "VkBool32", "shaderSharedFloat32AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSharedFloat64AtomicMinMax, "VkBool32", "shaderSharedFloat64AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderImageFloat32AtomicMinMax, "VkBool32", "shaderImageFloat32AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sparseImageFloat32AtomicMinMax, "VkBool32", "sparseImageFloat32AtomicMinMax", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGraphicsShaderGroupCount, "uint32_t", "maxGraphicsShaderGroupCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectSequenceCount, "uint32_t", "maxIndirectSequenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsTokenCount, "uint32_t", "maxIndirectCommandsTokenCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsStreamCount, "uint32_t", "maxIndirectCommandsStreamCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsTokenOffset, "uint32_t", "maxIndirectCommandsTokenOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsStreamStride, "uint32_t", "maxIndirectCommandsStreamStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minSequencesCountBufferOffsetAlignment, "uint32_t", "minSequencesCountBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minSequencesIndexBufferOffsetAlignment, "uint32_t", "minSequencesIndexBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minIndirectCommandsBufferOffsetAlignment, "uint32_t", "minIndirectCommandsBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedCommands, "VkBool32", "deviceGeneratedCommands", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGraphicsShaderGroupCreateInfoNV(ApiDumpInstance& api_dump, const VkGraphicsShaderGroupCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stageCount, "uint32_t", "stageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStages, object.stageCount, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pVertexInputState, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineVertexInputStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTessellationState, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineTessellationStateCreateInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGraphicsPipelineShaderGroupsCreateInfoNV(ApiDumpInstance& api_dump, const VkGraphicsPipelineShaderGroupsCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.groupCount, "uint32_t", "groupCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pGroups, object.groupCount, "const VkGraphicsShaderGroupCreateInfoNV*", "pGroups", "const VkGraphicsShaderGroupCreateInfoNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkGraphicsShaderGroupCreateInfoNV);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pipelineCount, "uint32_t", "pipelineCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPipelines, object.pipelineCount, "const VkPipeline*", "pPipelines", "const VkPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipeline);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindShaderGroupIndirectCommandNV(ApiDumpInstance& api_dump, const VkBindShaderGroupIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.groupIndex, "uint32_t", "groupIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindIndexBufferIndirectCommandNV(ApiDumpInstance& api_dump, const VkBindIndexBufferIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.bufferAddress, "VkDeviceAddress", "bufferAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindVertexBufferIndirectCommandNV(ApiDumpInstance& api_dump, const VkBindVertexBufferIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.bufferAddress, "VkDeviceAddress", "bufferAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stride, "uint32_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSetStateFlagsIndirectCommandNV(ApiDumpInstance& api_dump, const VkSetStateFlagsIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.data, "uint32_t", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsStreamNV(ApiDumpInstance& api_dump, const VkIndirectCommandsStreamNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsLayoutTokenNV(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutTokenNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsTokenTypeNV(api_dump, object.tokenType, "VkIndirectCommandsTokenTypeNV", "tokenType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stream, "uint32_t", "stream", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexBindingUnit, "uint32_t", "vertexBindingUnit", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexDynamicStride, "VkBool32", "vertexDynamicStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.pushconstantPipelineLayout, "VkPipelineLayout", "pushconstantPipelineLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.pushconstantShaderStageFlags, "VkShaderStageFlags", "pushconstantShaderStageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushconstantOffset, "uint32_t", "pushconstantOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushconstantSize, "uint32_t", "pushconstantSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectStateFlagsNV(api_dump, object.indirectStateFlags, "VkIndirectStateFlagsNV", "indirectStateFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.indexTypeCount, "uint32_t", "indexTypeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pIndexTypes, object.indexTypeCount, "const VkIndexType*", "pIndexTypes", "const VkIndexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndexType);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pIndexTypeValues, object.indexTypeCount, "const uint32_t*", "pIndexTypeValues", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsLayoutCreateInfoNV(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsLayoutUsageFlagsNV(api_dump, object.flags, "VkIndirectCommandsLayoutUsageFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tokenCount, "uint32_t", "tokenCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTokens, object.tokenCount, "const VkIndirectCommandsLayoutTokenNV*", "pTokens", "const VkIndirectCommandsLayoutTokenNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsLayoutTokenNV);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.streamCount, "uint32_t", "streamCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStreamStrides, object.streamCount, "const uint32_t*", "pStreamStrides", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeneratedCommandsInfoNV(ApiDumpInstance& api_dump, const VkGeneratedCommandsInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsLayoutNV(api_dump, object.indirectCommandsLayout, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.streamCount, "uint32_t", "streamCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStreams, object.streamCount, "const VkIndirectCommandsStreamNV*", "pStreams", "const VkIndirectCommandsStreamNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsStreamNV);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sequencesCount, "uint32_t", "sequencesCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.preprocessBuffer, "VkBuffer", "preprocessBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.preprocessOffset, "VkDeviceSize", "preprocessOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.preprocessSize, "VkDeviceSize", "preprocessSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.sequencesCountBuffer, "VkBuffer", "sequencesCountBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.sequencesCountOffset, "VkDeviceSize", "sequencesCountOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.sequencesIndexBuffer, "VkBuffer", "sequencesIndexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.sequencesIndexOffset, "VkDeviceSize", "sequencesIndexOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeneratedCommandsMemoryRequirementsInfoNV(ApiDumpInstance& api_dump, const VkGeneratedCommandsMemoryRequirementsInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsLayoutNV(api_dump, object.indirectCommandsLayout, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSequencesCount, "uint32_t", "maxSequencesCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceInheritedViewportScissorFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.inheritedViewportScissor2D, "VkBool32", "inheritedViewportScissor2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferInheritanceViewportScissorInfoNV(ApiDumpInstance& api_dump, const VkCommandBufferInheritanceViewportScissorInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.viewportScissor2D, "VkBool32", "viewportScissor2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.viewportDepthCount, "uint32_t", "viewportDepthCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pViewportDepths, "const VkViewport*", "pViewportDepths", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkViewport);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.texelBufferAlignment, "VkBool32", "texelBufferAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassTransformBeginInfoQCOM(ApiDumpInstance& api_dump, const VkRenderPassTransformBeginInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.transform, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(ApiDumpInstance& api_dump, const VkCommandBufferInheritanceRenderPassTransformInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.transform, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRect2D(api_dump, object.renderArea, "VkRect2D", "renderArea", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDepthBiasControlFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDepthBiasControlFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBiasControl, "VkBool32", "depthBiasControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.leastRepresentableValueForceUnormRepresentation, "VkBool32", "leastRepresentableValueForceUnormRepresentation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.floatRepresentation, "VkBool32", "floatRepresentation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBiasExact, "VkBool32", "depthBiasExact", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDepthBiasInfoEXT(ApiDumpInstance& api_dump, const VkDepthBiasInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.depthBiasConstantFactor, "float", "depthBiasConstantFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.depthBiasClamp, "float", "depthBiasClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.depthBiasSlopeFactor, "float", "depthBiasSlopeFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDepthBiasRepresentationInfoEXT(ApiDumpInstance& api_dump, const VkDepthBiasRepresentationInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDepthBiasRepresentationEXT(api_dump, object.depthBiasRepresentation, "VkDepthBiasRepresentationEXT", "depthBiasRepresentation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthBiasExact, "VkBool32", "depthBiasExact", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceMemoryReport, "VkBool32", "deviceMemoryReport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceMemoryReportCallbackDataEXT(ApiDumpInstance& api_dump, const VkDeviceMemoryReportCallbackDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemoryReportFlagsEXT(api_dump, object.flags, "VkDeviceMemoryReportFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemoryReportEventTypeEXT(api_dump, object.type, "VkDeviceMemoryReportEventTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.memoryObjectId, "uint64_t", "memoryObjectId", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkObjectType(api_dump, object.objectType, "VkObjectType", "objectType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_uint64_t_as_pointer(api_dump, object.objectHandle, "uint64_t", "objectHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.heapIndex, "uint32_t", "heapIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceDeviceMemoryReportCreateInfoEXT(ApiDumpInstance& api_dump, const VkDeviceDeviceMemoryReportCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemoryReportFlagsEXT(api_dump, object.flags, "VkDeviceMemoryReportFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkDeviceMemoryReportCallbackEXT(api_dump, object.pfnUserCallback, "PFN_vkDeviceMemoryReportCallbackEXT", "pfnUserCallback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pUserData, "void*", "pUserData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCustomBorderColorPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceCustomBorderColorPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCustomBorderColorSamplers, "uint32_t", "maxCustomBorderColorSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCustomBorderColorFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceCustomBorderColorFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.customBorderColors, "VkBool32", "customBorderColors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.customBorderColorWithoutFormat, "VkBool32", "customBorderColorWithoutFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureCompressionASTC_3D, "VkBool32", "textureCompressionASTC_3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentBarrierFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentBarrierFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentBarrier, "VkBool32", "presentBarrier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSurfaceCapabilitiesPresentBarrierNV(ApiDumpInstance& api_dump, const VkSurfaceCapabilitiesPresentBarrierNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentBarrierSupported, "VkBool32", "presentBarrierSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainPresentBarrierCreateInfoNV(ApiDumpInstance& api_dump, const VkSwapchainPresentBarrierCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentBarrierEnable, "VkBool32", "presentBarrierEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDiagnosticsConfigFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.diagnosticsConfig, "VkBool32", "diagnosticsConfig", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceDiagnosticsConfigCreateInfoNV(ApiDumpInstance& api_dump, const VkDeviceDiagnosticsConfigCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceDiagnosticsConfigFlagsNV(api_dump, object.flags, "VkDeviceDiagnosticsConfigFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkCudaModuleCreateInfoNV(ApiDumpInstance& api_dump, const VkCudaModuleCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dataSize, "size_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pData, "const void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCudaFunctionCreateInfoNV(ApiDumpInstance& api_dump, const VkCudaFunctionCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCudaModuleNV(api_dump, object.module, "VkCudaModuleNV", "module", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pName, "const char*", "pName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCudaLaunchInfoNV(ApiDumpInstance& api_dump, const VkCudaLaunchInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCudaFunctionNV(api_dump, object.function, "VkCudaFunctionNV", "function", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gridDimX, "uint32_t", "gridDimX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gridDimY, "uint32_t", "gridDimY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.gridDimZ, "uint32_t", "gridDimZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.blockDimX, "uint32_t", "blockDimX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.blockDimY, "uint32_t", "blockDimY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.blockDimZ, "uint32_t", "blockDimZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sharedMemBytes, "uint32_t", "sharedMemBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.paramCount, "size_t", "paramCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pParams, object.paramCount, "const void* const *", "pParams", "const void*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const void*>);
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.extraCount, "size_t", "extraCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pExtras, object.extraCount, "const void* const *", "pExtras", "const void*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const void*>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCudaKernelLaunchFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cudaKernelLaunchFeatures, "VkBool32", "cudaKernelLaunchFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCudaKernelLaunchPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.computeCapabilityMinor, "uint32_t", "computeCapabilityMinor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.computeCapabilityMajor, "uint32_t", "computeCapabilityMajor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceTileShadingFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTileShadingFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShading, "VkBool32", "tileShading", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingFragmentStage, "VkBool32", "tileShadingFragmentStage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingColorAttachments, "VkBool32", "tileShadingColorAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingDepthAttachments, "VkBool32", "tileShadingDepthAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingStencilAttachments, "VkBool32", "tileShadingStencilAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingInputAttachments, "VkBool32", "tileShadingInputAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingSampledAttachments, "VkBool32", "tileShadingSampledAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingPerTileDraw, "VkBool32", "tileShadingPerTileDraw", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingPerTileDispatch, "VkBool32", "tileShadingPerTileDispatch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingDispatchTile, "VkBool32", "tileShadingDispatchTile", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingApron, "VkBool32", "tileShadingApron", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingAnisotropicApron, "VkBool32", "tileShadingAnisotropicApron", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingAtomicOps, "VkBool32", "tileShadingAtomicOps", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileShadingImageProcessing, "VkBool32", "tileShadingImageProcessing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTileShadingPropertiesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTileShadingPropertiesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxApronSize, "uint32_t", "maxApronSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.preferNonCoherent, "VkBool32", "preferNonCoherent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.tileGranularity, "VkExtent2D", "tileGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxTileShadingRate, "VkExtent2D", "maxTileShadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassTileShadingCreateInfoQCOM(ApiDumpInstance& api_dump, const VkRenderPassTileShadingCreateInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTileShadingRenderPassFlagsQCOM(api_dump, object.flags, "VkTileShadingRenderPassFlagsQCOM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.tileApronSize, "VkExtent2D", "tileApronSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerTileBeginInfoQCOM(ApiDumpInstance& api_dump, const VkPerTileBeginInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerTileEndInfoQCOM(ApiDumpInstance& api_dump, const VkPerTileEndInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDispatchTileInfoQCOM(ApiDumpInstance& api_dump, const VkDispatchTileInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueryLowLatencySupportNV(ApiDumpInstance& api_dump, const VkQueryLowLatencySupportNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pQueriedLowLatencyData, "void*", "pQueriedLowLatencyData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkExportMetalObjectCreateInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalObjectCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExportMetalObjectTypeFlagBitsEXT(api_dump, object.exportObjectType, "VkExportMetalObjectTypeFlagBitsEXT", "exportObjectType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalObjectsInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalObjectsInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalDeviceInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalDeviceInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLDevice_id>(api_dump, object.mtlDevice, "MTLDevice_id", "mtlDevice", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalCommandQueueInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalCommandQueueInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueue(api_dump, object.queue, "VkQueue", "queue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLCommandQueue_id>(api_dump, object.mtlCommandQueue, "MTLCommandQueue_id", "mtlCommandQueue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalBufferInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalBufferInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLBuffer_id>(api_dump, object.mtlBuffer, "MTLBuffer_id", "mtlBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportMetalBufferInfoEXT(ApiDumpInstance& api_dump, const VkImportMetalBufferInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLBuffer_id>(api_dump, object.mtlBuffer, "MTLBuffer_id", "mtlBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalTextureInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalTextureInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferView(api_dump, object.bufferView, "VkBufferView", "bufferView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlagBits(api_dump, object.plane, "VkImageAspectFlagBits", "plane", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLTexture_id>(api_dump, object.mtlTexture, "MTLTexture_id", "mtlTexture", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportMetalTextureInfoEXT(ApiDumpInstance& api_dump, const VkImportMetalTextureInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageAspectFlagBits(api_dump, object.plane, "VkImageAspectFlagBits", "plane", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLTexture_id>(api_dump, object.mtlTexture, "MTLTexture_id", "mtlTexture", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalIOSurfaceInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalIOSurfaceInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<IOSurfaceRef>(api_dump, object.ioSurface, "IOSurfaceRef", "ioSurface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportMetalIOSurfaceInfoEXT(ApiDumpInstance& api_dump, const VkImportMetalIOSurfaceInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<IOSurfaceRef>(api_dump, object.ioSurface, "IOSurfaceRef", "ioSurface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExportMetalSharedEventInfoEXT(ApiDumpInstance& api_dump, const VkExportMetalSharedEventInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkEvent(api_dump, object.event, "VkEvent", "event", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLSharedEvent_id>(api_dump, object.mtlSharedEvent, "MTLSharedEvent_id", "mtlSharedEvent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportMetalSharedEventInfoEXT(ApiDumpInstance& api_dump, const VkImportMetalSharedEventInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<MTLSharedEvent_id>(api_dump, object.mtlSharedEvent, "MTLSharedEvent_id", "mtlSharedEvent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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_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_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_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_VkDeviceFaultAddressInfoEXT(const VkDeviceFaultAddressInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
-    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
-    dump_VkDeviceFaultAddressTypeEXT<Format>(object.addressType, settings, "VkDeviceFaultAddressTypeEXT", "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_VkDeviceFaultVendorInfoEXT(const VkDeviceFaultVendorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, 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_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, "VkDeviceFaultAddressInfoEXT*", "pAddressInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultAddressInfoEXT<Format>);
-    dump_separate_members<Format>(settings);
-    dump_pointer<Format>(object.pVendorInfos, settings, "VkDeviceFaultVendorInfoEXT*", "pVendorInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultVendorInfoEXT<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_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(const VkDeviceFaultVendorBinaryHeaderVersionOneEXT& object, const ApiDumpSettings& settings, const char* type_name, 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_VkDeviceFaultVendorBinaryHeaderVersionEXT<Format>(object.headerVersion, settings, "VkDeviceFaultVendorBinaryHeaderVersionEXT", "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_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);
+void dump_VkPhysicalDeviceDescriptorBufferPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorBufferPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.combinedImageSamplerDescriptorSingleArray, "VkBool32", "combinedImageSamplerDescriptorSingleArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bufferlessPushDescriptors, "VkBool32", "bufferlessPushDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.allowSamplerImageViewPostSubmitCreation, "VkBool32", "allowSamplerImageViewPostSubmitCreation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.descriptorBufferOffsetAlignment, "VkDeviceSize", "descriptorBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorBufferBindings, "uint32_t", "maxDescriptorBufferBindings", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxResourceDescriptorBufferBindings, "uint32_t", "maxResourceDescriptorBufferBindings", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSamplerDescriptorBufferBindings, "uint32_t", "maxSamplerDescriptorBufferBindings", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxEmbeddedImmutableSamplerBindings, "uint32_t", "maxEmbeddedImmutableSamplerBindings", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxEmbeddedImmutableSamplers, "uint32_t", "maxEmbeddedImmutableSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.bufferCaptureReplayDescriptorDataSize, "size_t", "bufferCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.imageCaptureReplayDescriptorDataSize, "size_t", "imageCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.imageViewCaptureReplayDescriptorDataSize, "size_t", "imageViewCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.samplerCaptureReplayDescriptorDataSize, "size_t", "samplerCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.accelerationStructureCaptureReplayDescriptorDataSize, "size_t", "accelerationStructureCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.samplerDescriptorSize, "size_t", "samplerDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.combinedImageSamplerDescriptorSize, "size_t", "combinedImageSamplerDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.sampledImageDescriptorSize, "size_t", "sampledImageDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.storageImageDescriptorSize, "size_t", "storageImageDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.uniformTexelBufferDescriptorSize, "size_t", "uniformTexelBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.robustUniformTexelBufferDescriptorSize, "size_t", "robustUniformTexelBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.storageTexelBufferDescriptorSize, "size_t", "storageTexelBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.robustStorageTexelBufferDescriptorSize, "size_t", "robustStorageTexelBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.uniformBufferDescriptorSize, "size_t", "uniformBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.robustUniformBufferDescriptorSize, "size_t", "robustUniformBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.storageBufferDescriptorSize, "size_t", "storageBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.robustStorageBufferDescriptorSize, "size_t", "robustStorageBufferDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.inputAttachmentDescriptorSize, "size_t", "inputAttachmentDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.accelerationStructureDescriptorSize, "size_t", "accelerationStructureDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxSamplerDescriptorBufferRange, "VkDeviceSize", "maxSamplerDescriptorBufferRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxResourceDescriptorBufferRange, "VkDeviceSize", "maxResourceDescriptorBufferRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.samplerDescriptorBufferAddressSpaceSize, "VkDeviceSize", "samplerDescriptorBufferAddressSpaceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.resourceDescriptorBufferAddressSpaceSize, "VkDeviceSize", "resourceDescriptorBufferAddressSpaceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.descriptorBufferAddressSpaceSize, "VkDeviceSize", "descriptorBufferAddressSpaceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.combinedImageSamplerDensityMapDescriptorSize, "size_t", "combinedImageSamplerDensityMapDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorBufferFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorBufferFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBuffer, "VkBool32", "descriptorBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBufferCaptureReplay, "VkBool32", "descriptorBufferCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBufferImageLayoutIgnored, "VkBool32", "descriptorBufferImageLayoutIgnored", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBufferPushDescriptors, "VkBool32", "descriptorBufferPushDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorAddressInfoEXT(ApiDumpInstance& api_dump, const VkDescriptorAddressInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.address, "VkDeviceAddress", "address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.range, "VkDeviceSize", "range", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorBufferBindingInfoEXT(ApiDumpInstance& api_dump, const VkDescriptorBufferBindingInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.address, "VkDeviceAddress", "address", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferUsageFlags(api_dump, object.usage, "VkBufferUsageFlags", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(ApiDumpInstance& api_dump, const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorDataEXT(ApiDumpInstance& api_dump, const VkDescriptorDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLER) {
+        dump_pointer(api_dump, object.pSampler, "const VkSampler*", "pSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSampler);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+        dump_pointer(api_dump, object.pCombinedImageSampler, "const VkDescriptorImageInfo*", "pCombinedImageSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) {
+        dump_pointer(api_dump, object.pInputAttachmentImage, "const VkDescriptorImageInfo*", "pInputAttachmentImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) {
+        dump_pointer(api_dump, object.pSampledImage, "const VkDescriptorImageInfo*", "pSampledImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
+        dump_pointer(api_dump, object.pStorageImage, "const VkDescriptorImageInfo*", "pStorageImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) {
+        dump_pointer(api_dump, object.pUniformTexelBuffer, "const VkDescriptorAddressInfoEXT*", "pUniformTexelBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
+        dump_pointer(api_dump, object.pStorageTexelBuffer, "const VkDescriptorAddressInfoEXT*", "pStorageTexelBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) {
+        dump_pointer(api_dump, object.pUniformBuffer, "const VkDescriptorAddressInfoEXT*", "pUniformBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
+        dump_pointer(api_dump, object.pStorageBuffer, "const VkDescriptorAddressInfoEXT*", "pStorageBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) {
+        dump_type_hex<VkDeviceAddress>(api_dump, object.accelerationStructure, "VkDeviceAddress", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorGetInfoEXT(ApiDumpInstance& api_dump, const VkDescriptorGetInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setDescriptorType(object.type);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorType(api_dump, object.type, "VkDescriptorType", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorDataEXT(api_dump, object.data, "VkDescriptorDataEXT", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCaptureDescriptorDataInfoEXT(ApiDumpInstance& api_dump, const VkBufferCaptureDescriptorDataInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageCaptureDescriptorDataInfoEXT(ApiDumpInstance& api_dump, const VkImageCaptureDescriptorDataInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImage(api_dump, object.image, "VkImage", "image", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewCaptureDescriptorDataInfoEXT(ApiDumpInstance& api_dump, const VkImageViewCaptureDescriptorDataInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageView(api_dump, object.imageView, "VkImageView", "imageView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerCaptureDescriptorDataInfoEXT(ApiDumpInstance& api_dump, const VkSamplerCaptureDescriptorDataInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampler(api_dump, object.sampler, "VkSampler", "sampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpaqueCaptureDescriptorDataCreateInfoEXT(ApiDumpInstance& api_dump, const VkOpaqueCaptureDescriptorDataCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.opaqueCaptureDescriptorData, "const void*", "opaqueCaptureDescriptorData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT(ApiDumpInstance& api_dump, const VkAccelerationStructureCaptureDescriptorDataInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.accelerationStructure, "VkAccelerationStructureKHR", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureNV(api_dump, object.accelerationStructureNV, "VkAccelerationStructureNV", "accelerationStructureNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.graphicsPipelineLibrary, "VkBool32", "graphicsPipelineLibrary", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.graphicsPipelineLibraryFastLinking, "VkBool32", "graphicsPipelineLibraryFastLinking", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.graphicsPipelineLibraryIndependentInterpolationDecoration, "VkBool32", "graphicsPipelineLibraryIndependentInterpolationDecoration", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGraphicsPipelineLibraryCreateInfoEXT(ApiDumpInstance& api_dump, const VkGraphicsPipelineLibraryCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGraphicsPipelineLibraryFlagsEXT(api_dump, object.flags, "VkGraphicsPipelineLibraryFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderEarlyAndLateFragmentTests, "VkBool32", "shaderEarlyAndLateFragmentTests", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentShadingRateEnums, "VkBool32", "fragmentShadingRateEnums", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.supersampleFragmentShadingRates, "VkBool32", "supersampleFragmentShadingRates", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.noInvocationFragmentShadingRates, "VkBool32", "noInvocationFragmentShadingRates", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.maxFragmentShadingRateInvocationCount, "VkSampleCountFlagBits", "maxFragmentShadingRateInvocationCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(ApiDumpInstance& api_dump, const VkPipelineFragmentShadingRateEnumStateCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFragmentShadingRateTypeNV(api_dump, object.shadingRateType, "VkFragmentShadingRateTypeNV", "shadingRateType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFragmentShadingRateNV(api_dump, object.shadingRate, "VkFragmentShadingRateNV", "shadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.combinerOps, 2, "VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "VkFragmentShadingRateCombinerOpKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFragmentShadingRateCombinerOpKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceOrHostAddressConstKHR(ApiDumpInstance& api_dump, const VkDeviceOrHostAddressConstKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.hostAddress, "const void*", "hostAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryMotionTrianglesDataNV(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryMotionTrianglesDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.vertexData, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureMotionInfoNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMotionInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInstances, "uint32_t", "maxInstances", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureMotionInfoFlagsNV(api_dump, object.flags, "VkAccelerationStructureMotionInfoFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureMatrixMotionInstanceNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMatrixMotionInstanceNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkTransformMatrixKHR(api_dump, object.transformT0, "VkTransformMatrixKHR", "transformT0", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTransformMatrixKHR(api_dump, object.transformT1, "VkTransformMatrixKHR", "transformT1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCustomIndex, "uint32_t:24", "instanceCustomIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mask, "uint32_t:8", "mask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceShaderBindingTableRecordOffset, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryInstanceFlagsKHR(api_dump, object.flags, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.accelerationStructureReference, "uint64_t", "accelerationStructureReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSRTDataNV(ApiDumpInstance& api_dump, const VkSRTDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.sx, "float", "sx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.a, "float", "a", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.b, "float", "b", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.pvx, "float", "pvx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.sy, "float", "sy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.c, "float", "c", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.pvy, "float", "pvy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.sz, "float", "sz", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.pvz, "float", "pvz", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.qx, "float", "qx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.qy, "float", "qy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.qz, "float", "qz", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.qw, "float", "qw", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.tx, "float", "tx", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.ty, "float", "ty", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.tz, "float", "tz", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureSRTMotionInstanceNV(ApiDumpInstance& api_dump, const VkAccelerationStructureSRTMotionInstanceNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkSRTDataNV(api_dump, object.transformT0, "VkSRTDataNV", "transformT0", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSRTDataNV(api_dump, object.transformT1, "VkSRTDataNV", "transformT1", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCustomIndex, "uint32_t:24", "instanceCustomIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mask, "uint32_t:8", "mask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceShaderBindingTableRecordOffset, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryInstanceFlagsKHR(api_dump, object.flags, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.accelerationStructureReference, "uint64_t", "accelerationStructureReference", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureMotionInstanceDataNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMotionInstanceDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_VkAccelerationStructureInstanceKHR(api_dump, object.staticInstance, "VkAccelerationStructureInstanceKHR", "staticInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureMatrixMotionInstanceNV(api_dump, object.matrixMotionInstance, "VkAccelerationStructureMatrixMotionInstanceNV", "matrixMotionInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureSRTMotionInstanceNV(api_dump, object.srtMotionInstance, "VkAccelerationStructureSRTMotionInstanceNV", "srtMotionInstance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureMotionInstanceNV(ApiDumpInstance& api_dump, const VkAccelerationStructureMotionInstanceNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkAccelerationStructureMotionInstanceTypeNV(api_dump, object.type, "VkAccelerationStructureMotionInstanceTypeNV", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureMotionInstanceFlagsNV(api_dump, object.flags, "VkAccelerationStructureMotionInstanceFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureMotionInstanceDataNV(api_dump, object.data, "VkAccelerationStructureMotionInstanceDataNV", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingMotionBlur, "VkBool32", "rayTracingMotionBlur", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingMotionBlurPipelineTraceRaysIndirect, "VkBool32", "rayTracingMotionBlurPipelineTraceRaysIndirect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.ycbcr2plane444Formats, "VkBool32", "ycbcr2plane444Formats", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityMapDeferred, "VkBool32", "fragmentDensityMapDeferred", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subsampledLoads, "VkBool32", "subsampledLoads", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subsampledCoarseReconstructionEarlyAccess, "VkBool32", "subsampledCoarseReconstructionEarlyAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSubsampledArrayLayers, "uint32_t", "maxSubsampledArrayLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetSubsampledSamplers, "uint32_t", "maxDescriptorSetSubsampledSamplers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyCommandTransformInfoQCOM(ApiDumpInstance& api_dump, const VkCopyCommandTransformInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceTransformFlagBitsKHR(api_dump, object.transform, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageCompressionControlFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageCompressionControlFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageCompressionControl, "VkBool32", "imageCompressionControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageCompressionControlEXT(ApiDumpInstance& api_dump, const VkImageCompressionControlEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCompressionFlagsEXT(api_dump, object.flags, "VkImageCompressionFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.compressionControlPlaneCount, "uint32_t", "compressionControlPlaneCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pFixedRateFlags, object.compressionControlPlaneCount, "VkImageCompressionFixedRateFlagsEXT*", "pFixedRateFlags", "VkImageCompressionFixedRateFlagsEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCompressionFixedRateFlagsEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageCompressionPropertiesEXT(ApiDumpInstance& api_dump, const VkImageCompressionPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCompressionFlagsEXT(api_dump, object.imageCompressionFlags, "VkImageCompressionFlagsEXT", "imageCompressionFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCompressionFixedRateFlagsEXT(api_dump, object.imageCompressionFixedRateFlags, "VkImageCompressionFixedRateFlagsEXT", "imageCompressionFixedRateFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.attachmentFeedbackLoopLayout, "VkBool32", "attachmentFeedbackLoopLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevice4444FormatsFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevice4444FormatsFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.formatA4R4G4B4, "VkBool32", "formatA4R4G4B4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.formatA4B4G4R4, "VkBool32", "formatA4B4G4R4", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFaultFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFaultFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceFault, "VkBool32", "deviceFault", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceFaultVendorBinary, "VkBool32", "deviceFaultVendorBinary", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceFaultCountsEXT(ApiDumpInstance& api_dump, const VkDeviceFaultCountsEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.addressInfoCount, "uint32_t", "addressInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vendorInfoCount, "uint32_t", "vendorInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.vendorBinarySize, "VkDeviceSize", "vendorBinarySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceFaultAddressInfoEXT(ApiDumpInstance& api_dump, const VkDeviceFaultAddressInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkDeviceFaultAddressTypeEXT(api_dump, object.addressType, "VkDeviceFaultAddressTypeEXT", "addressType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.reportedAddress, "VkDeviceAddress", "reportedAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.addressPrecision, "VkDeviceSize", "addressPrecision", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceFaultVendorInfoEXT(ApiDumpInstance& api_dump, const VkDeviceFaultVendorInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.vendorFaultCode, "uint64_t", "vendorFaultCode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.vendorFaultData, "uint64_t", "vendorFaultData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceFaultInfoEXT(ApiDumpInstance& api_dump, const VkDeviceFaultInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pAddressInfos, "VkDeviceFaultAddressInfoEXT*", "pAddressInfos", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultAddressInfoEXT);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pVendorInfos, "VkDeviceFaultVendorInfoEXT*", "pVendorInfos", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultVendorInfoEXT);
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pVendorBinaryData, "void*", "pVendorBinaryData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(ApiDumpInstance& api_dump, const VkDeviceFaultVendorBinaryHeaderVersionOneEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.headerSize, "uint32_t", "headerSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceFaultVendorBinaryHeaderVersionEXT(api_dump, object.headerVersion, "VkDeviceFaultVendorBinaryHeaderVersionEXT", "headerVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vendorID, "uint32_t", "vendorID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceID, "uint32_t", "deviceID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.driverVersion, "uint32_t", "driverVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.pipelineCacheUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.applicationNameOffset, "uint32_t", "applicationNameOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.applicationVersion, "uint32_t", "applicationVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.engineNameOffset, "uint32_t", "engineNameOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.engineVersion, "uint32_t", "engineVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_api_version(api_dump, object.apiVersion, "uint32_t", "apiVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rasterizationOrderColorAttachmentAccess, "VkBool32", "rasterizationOrderColorAttachmentAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rasterizationOrderDepthAttachmentAccess, "VkBool32", "rasterizationOrderDepthAttachmentAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rasterizationOrderStencilAttachmentAccess, "VkBool32", "rasterizationOrderStencilAttachmentAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.formatRgba10x6WithoutYCbCrSampler, "VkBool32", "formatRgba10x6WithoutYCbCrSampler", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkDirectFBSurfaceCreateInfoEXT(ApiDumpInstance& api_dump, const VkDirectFBSurfaceCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDirectFBSurfaceCreateFlagsEXT(api_dump, object.flags, "VkDirectFBSurfaceCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<IDirectFB*>(api_dump, object.dfb, "IDirectFB*", "dfb", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<IDirectFBSurface*>(api_dump, object.surface, "IDirectFBSurface*", "surface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.mutableDescriptorType, "VkBool32", "mutableDescriptorType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMutableDescriptorTypeListEXT(ApiDumpInstance& api_dump, const VkMutableDescriptorTypeListEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.descriptorTypeCount, "uint32_t", "descriptorTypeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDescriptorTypes, object.descriptorTypeCount, "const VkDescriptorType*", "pDescriptorTypes", "const VkDescriptorType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorType);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMutableDescriptorTypeCreateInfoEXT(ApiDumpInstance& api_dump, const VkMutableDescriptorTypeCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.mutableDescriptorTypeListCount, "uint32_t", "mutableDescriptorTypeListCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pMutableDescriptorTypeLists, object.mutableDescriptorTypeListCount, "const VkMutableDescriptorTypeListEXT*", "pMutableDescriptorTypeLists", "const VkMutableDescriptorTypeListEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMutableDescriptorTypeListEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexInputDynamicState, "VkBool32", "vertexInputDynamicState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVertexInputBindingDescription2EXT(ApiDumpInstance& api_dump, const VkVertexInputBindingDescription2EXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stride, "uint32_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVertexInputRate(api_dump, object.inputRate, "VkVertexInputRate", "inputRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.divisor, "uint32_t", "divisor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVertexInputAttributeDescription2EXT(ApiDumpInstance& api_dump, const VkVertexInputAttributeDescription2EXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.location, "uint32_t", "location", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDrmPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDrmPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasPrimary, "VkBool32", "hasPrimary", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hasRender, "VkBool32", "hasRender", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.primaryMajor, "int64_t", "primaryMajor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.primaryMinor, "int64_t", "primaryMinor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.renderMajor, "int64_t", "renderMajor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.renderMinor, "int64_t", "renderMinor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceAddressBindingReportFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceAddressBindingReportFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.reportAddressBinding, "VkBool32", "reportAddressBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceAddressBindingCallbackDataEXT(ApiDumpInstance& api_dump, const VkDeviceAddressBindingCallbackDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceAddressBindingFlagsEXT(api_dump, object.flags, "VkDeviceAddressBindingFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.baseAddress, "VkDeviceAddress", "baseAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceAddressBindingTypeEXT(api_dump, object.bindingType, "VkDeviceAddressBindingTypeEXT", "bindingType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDepthClipControlFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDepthClipControlFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClipControl, "VkBool32", "depthClipControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportDepthClipControlCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineViewportDepthClipControlCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.negativeOneToOne, "VkBool32", "negativeOneToOne", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveTopologyListRestart, "VkBool32", "primitiveTopologyListRestart", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveTopologyPatchListRestart, "VkBool32", "primitiveTopologyPatchListRestart", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportMemoryZirconHandleInfoFUCHSIA(ApiDumpInstance& api_dump, const VkImportMemoryZirconHandleInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<zx_handle_t>(api_dump, object.handle, "zx_handle_t", "handle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance& api_dump, const VkMemoryZirconHandlePropertiesFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetZirconHandleInfoFUCHSIA(ApiDumpInstance& api_dump, const VkMemoryGetZirconHandleInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportSemaphoreZirconHandleInfoFUCHSIA(ApiDumpInstance& api_dump, const VkImportSemaphoreZirconHandleInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphoreImportFlags(api_dump, object.flags, "VkSemaphoreImportFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<zx_handle_t>(api_dump, object.zirconHandle, "zx_handle_t", "zirconHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSemaphoreGetZirconHandleInfoFUCHSIA(ApiDumpInstance& api_dump, const VkSemaphoreGetZirconHandleInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.semaphore, "VkSemaphore", "semaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlagBits(api_dump, object.handleType, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCollectionCreateInfoFUCHSIA(ApiDumpInstance& api_dump, const VkBufferCollectionCreateInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<zx_handle_t>(api_dump, object.collectionToken, "zx_handle_t", "collectionToken", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportMemoryBufferCollectionFUCHSIA(ApiDumpInstance& api_dump, const VkImportMemoryBufferCollectionFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCollectionFUCHSIA(api_dump, object.collection, "VkBufferCollectionFUCHSIA", "collection", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCollectionImageCreateInfoFUCHSIA(ApiDumpInstance& api_dump, const VkBufferCollectionImageCreateInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCollectionFUCHSIA(api_dump, object.collection, "VkBufferCollectionFUCHSIA", "collection", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCollectionConstraintsInfoFUCHSIA(ApiDumpInstance& api_dump, const VkBufferCollectionConstraintsInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minBufferCount, "uint32_t", "minBufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxBufferCount, "uint32_t", "maxBufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minBufferCountForCamping, "uint32_t", "minBufferCountForCamping", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minBufferCountForDedicatedSlack, "uint32_t", "minBufferCountForDedicatedSlack", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minBufferCountForSharedSlack, "uint32_t", "minBufferCountForSharedSlack", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferConstraintsInfoFUCHSIA(ApiDumpInstance& api_dump, const VkBufferConstraintsInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCreateInfo(api_dump, object.createInfo, "VkBufferCreateInfo", "createInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.requiredFormatFeatures, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCollectionConstraintsInfoFUCHSIA(api_dump, object.bufferCollectionConstraints, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCollectionBufferCreateInfoFUCHSIA(ApiDumpInstance& api_dump, const VkBufferCollectionBufferCreateInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferCollectionFUCHSIA(api_dump, object.collection, "VkBufferCollectionFUCHSIA", "collection", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSysmemColorSpaceFUCHSIA(ApiDumpInstance& api_dump, const VkSysmemColorSpaceFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorSpace, "uint32_t", "colorSpace", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBufferCollectionPropertiesFUCHSIA(ApiDumpInstance& api_dump, const VkBufferCollectionPropertiesFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferCount, "uint32_t", "bufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.createInfoIndex, "uint32_t", "createInfoIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.sysmemPixelFormat, "uint64_t", "sysmemPixelFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.formatFeatures, "VkFormatFeatureFlags", "formatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSysmemColorSpaceFUCHSIA(api_dump, object.sysmemColorSpaceIndex, "VkSysmemColorSpaceFUCHSIA", "sysmemColorSpaceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.samplerYcbcrConversionComponents, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrModelConversion(api_dump, object.suggestedYcbcrModel, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrRange(api_dump, object.suggestedYcbcrRange, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedXChromaOffset, "VkChromaLocation", "suggestedXChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedYChromaOffset, "VkChromaLocation", "suggestedYChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageFormatConstraintsInfoFUCHSIA(ApiDumpInstance& api_dump, const VkImageFormatConstraintsInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageCreateInfo(api_dump, object.imageCreateInfo, "VkImageCreateInfo", "imageCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.requiredFormatFeatures, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageFormatConstraintsFlagsFUCHSIA(api_dump, object.flags, "VkImageFormatConstraintsFlagsFUCHSIA", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.sysmemPixelFormat, "uint64_t", "sysmemPixelFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorSpaceCount, "uint32_t", "colorSpaceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorSpaces, object.colorSpaceCount, "const VkSysmemColorSpaceFUCHSIA*", "pColorSpaces", "const VkSysmemColorSpaceFUCHSIA", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSysmemColorSpaceFUCHSIA);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageConstraintsInfoFUCHSIA(ApiDumpInstance& api_dump, const VkImageConstraintsInfoFUCHSIA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.formatConstraintsCount, "uint32_t", "formatConstraintsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pFormatConstraints, object.formatConstraintsCount, "const VkImageFormatConstraintsInfoFUCHSIA*", "pFormatConstraints", "const VkImageFormatConstraintsInfoFUCHSIA", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImageFormatConstraintsInfoFUCHSIA);
+    dump_separate_members(api_dump);
+    dump_VkBufferCollectionConstraintsInfoFUCHSIA(api_dump, object.bufferCollectionConstraints, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageConstraintsInfoFlagsFUCHSIA(api_dump, object.flags, "VkImageConstraintsInfoFlagsFUCHSIA", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkSubpassShadingPipelineCreateInfoHUAWEI(ApiDumpInstance& api_dump, const VkSubpassShadingPipelineCreateInfoHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRenderPass(api_dump, object.renderPass, "VkRenderPass", "renderPass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subpass, "uint32_t", "subpass", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subpassShading, "VkBool32", "subpassShading", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSubpassShadingWorkgroupSizeAspectRatio, "uint32_t", "maxSubpassShadingWorkgroupSizeAspectRatio", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.invocationMask, "VkBool32", "invocationMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetRemoteAddressInfoNV(ApiDumpInstance& api_dump, const VkMemoryGetRemoteAddressInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.externalMemoryRDMA, "VkBool32", "externalMemoryRDMA", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelinePropertiesIdentifierEXT(ApiDumpInstance& api_dump, const VkPipelinePropertiesIdentifierEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.pipelineIdentifier, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "pipelineIdentifier", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelinePropertiesFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelinePropertiesFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelinePropertiesIdentifier, "VkBool32", "pipelinePropertiesIdentifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFrameBoundaryFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFrameBoundaryFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.frameBoundary, "VkBool32", "frameBoundary", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFrameBoundaryEXT(ApiDumpInstance& api_dump, const VkFrameBoundaryEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFrameBoundaryFlagsEXT(api_dump, object.flags, "VkFrameBoundaryFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.frameID, "uint64_t", "frameID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.imageCount, "uint32_t", "imageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pImages, object.imageCount, "const VkImage*", "pImages", "const VkImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkImage);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bufferCount, "uint32_t", "bufferCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pBuffers, object.bufferCount, "const VkBuffer*", "pBuffers", "const VkBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkBuffer);
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.tagName, "uint64_t", "tagName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tagSize, "size_t", "tagSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pTag, "const void*", "pTag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multisampledRenderToSingleSampled, "VkBool32", "multisampledRenderToSingleSampled", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSubpassResolvePerformanceQueryEXT(ApiDumpInstance& api_dump, const VkSubpassResolvePerformanceQueryEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.optimal, "VkBool32", "optimal", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMultisampledRenderToSingleSampledInfoEXT(ApiDumpInstance& api_dump, const VkMultisampledRenderToSingleSampledInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multisampledRenderToSingleSampledEnable, "VkBool32", "multisampledRenderToSingleSampledEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSampleCountFlagBits(api_dump, object.rasterizationSamples, "VkSampleCountFlagBits", "rasterizationSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState2, "VkBool32", "extendedDynamicState2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState2LogicOp, "VkBool32", "extendedDynamicState2LogicOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState2PatchControlPoints, "VkBool32", "extendedDynamicState2PatchControlPoints", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkScreenSurfaceCreateInfoQNX(ApiDumpInstance& api_dump, const VkScreenSurfaceCreateInfoQNX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkScreenSurfaceCreateFlagsQNX(api_dump, object.flags, "VkScreenSurfaceCreateFlagsQNX", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct _screen_context*>(api_dump, object.context, "struct _screen_context*", "context", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct _screen_window*>(api_dump, object.window, "struct _screen_window*", "window", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
-}
-template <ApiDumpFormat Format>
-void dump_VkMicromapTriangleEXT(const VkMicromapTriangleEXT& object, const ApiDumpSettings& settings, const char* type_name, 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);
+void dump_VkPhysicalDeviceColorWriteEnableFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceColorWriteEnableFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.colorWriteEnable, "VkBool32", "colorWriteEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineColorWriteCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineColorWriteCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.attachmentCount, "uint32_t", "attachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorWriteEnables, object.attachmentCount, "const VkBool32*", "pColorWriteEnables", "const VkBool32", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const VkBool32>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitivesGeneratedQuery, "VkBool32", "primitivesGeneratedQuery", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitivesGeneratedQueryWithRasterizerDiscard, "VkBool32", "primitivesGeneratedQueryWithRasterizerDiscard", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitivesGeneratedQueryWithNonZeroStreams, "VkBool32", "primitivesGeneratedQueryWithNonZeroStreams", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(ApiDumpInstance& api_dump, const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.videoEncodeRgbConversion, "VkBool32", "videoEncodeRgbConversion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeRgbConversionCapabilitiesVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeRgbConversionCapabilitiesVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbModelConversionFlagsVALVE(api_dump, object.rgbModels, "VkVideoEncodeRgbModelConversionFlagsVALVE", "rgbModels", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbRangeCompressionFlagsVALVE(api_dump, object.rgbRanges, "VkVideoEncodeRgbRangeCompressionFlagsVALVE", "rgbRanges", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(api_dump, object.xChromaOffsets, "VkVideoEncodeRgbChromaOffsetFlagsVALVE", "xChromaOffsets", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(api_dump, object.yChromaOffsets, "VkVideoEncodeRgbChromaOffsetFlagsVALVE", "yChromaOffsets", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeProfileRgbConversionInfoVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeProfileRgbConversionInfoVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.performEncodeRgbConversion, "VkBool32", "performEncodeRgbConversion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(ApiDumpInstance& api_dump, const VkVideoEncodeSessionRgbConversionCreateInfoVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(api_dump, object.rgbModel, "VkVideoEncodeRgbModelConversionFlagBitsVALVE", "rgbModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(api_dump, object.rgbRange, "VkVideoEncodeRgbRangeCompressionFlagBitsVALVE", "rgbRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(api_dump, object.xChromaOffset, "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE", "xChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(api_dump, object.yChromaOffset, "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE", "yChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageViewMinLodFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageViewMinLodFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.minLod, "VkBool32", "minLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewMinLodCreateInfoEXT(ApiDumpInstance& api_dump, const VkImageViewMinLodCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.minLod, "float", "minLod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiDrawFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiDrawFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiDraw, "VkBool32", "multiDraw", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiDrawPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiDrawPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMultiDrawCount, "uint32_t", "maxMultiDrawCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMultiDrawInfoEXT(ApiDumpInstance& api_dump, const VkMultiDrawInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.firstVertex, "uint32_t", "firstVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexCount, "uint32_t", "vertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMultiDrawIndexedInfoEXT(ApiDumpInstance& api_dump, const VkMultiDrawIndexedInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.firstIndex, "uint32_t", "firstIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.indexCount, "uint32_t", "indexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.vertexOffset, "int32_t", "vertexOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.image2DViewOf3D, "VkBool32", "image2DViewOf3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.sampler2DViewOf3D, "VkBool32", "sampler2DViewOf3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderTileImageFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderTileImageFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTileImageColorReadAccess, "VkBool32", "shaderTileImageColorReadAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTileImageDepthReadAccess, "VkBool32", "shaderTileImageDepthReadAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTileImageStencilReadAccess, "VkBool32", "shaderTileImageStencilReadAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderTileImagePropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderTileImagePropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTileImageCoherentReadAccelerated, "VkBool32", "shaderTileImageCoherentReadAccelerated", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTileImageReadSampleFromPixelRateInvocation, "VkBool32", "shaderTileImageReadSampleFromPixelRateInvocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTileImageReadFromHelperInvocation, "VkBool32", "shaderTileImageReadFromHelperInvocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMicromapUsageEXT(ApiDumpInstance& api_dump, const VkMicromapUsageEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.count, "uint32_t", "count", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.subdivisionLevel, "uint32_t", "subdivisionLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.format, "uint32_t", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceOrHostAddressKHR(ApiDumpInstance& api_dump, const VkDeviceOrHostAddressKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.hostAddress, "void*", "hostAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMicromapBuildInfoEXT(ApiDumpInstance& api_dump, const VkMicromapBuildInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapTypeEXT(api_dump, object.type, "VkMicromapTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildMicromapFlagsEXT(api_dump, object.flags, "VkBuildMicromapFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildMicromapModeEXT(api_dump, object.mode, "VkBuildMicromapModeEXT", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.dstMicromap, "VkMicromapEXT", "dstMicromap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.usageCountsCount, "uint32_t", "usageCountsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pUsageCounts, object.usageCountsCount, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT);
+    dump_separate_members(api_dump);
+    dump_double_pointer_array(api_dump, object.ppUsageCounts, object.usageCountsCount * 1, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT);
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.data, "VkDeviceOrHostAddressConstKHR", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressKHR(api_dump, object.scratchData, "VkDeviceOrHostAddressKHR", "scratchData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.triangleArray, "VkDeviceOrHostAddressConstKHR", "triangleArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.triangleArrayStride, "VkDeviceSize", "triangleArrayStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMicromapCreateInfoEXT(ApiDumpInstance& api_dump, const VkMicromapCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapCreateFlagsEXT(api_dump, object.createFlags, "VkMicromapCreateFlagsEXT", "createFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapTypeEXT(api_dump, object.type, "VkMicromapTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceOpacityMicromapFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceOpacityMicromapFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.micromap, "VkBool32", "micromap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.micromapCaptureReplay, "VkBool32", "micromapCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.micromapHostCommands, "VkBool32", "micromapHostCommands", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceOpacityMicromapPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceOpacityMicromapPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxOpacity2StateSubdivisionLevel, "uint32_t", "maxOpacity2StateSubdivisionLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxOpacity4StateSubdivisionLevel, "uint32_t", "maxOpacity4StateSubdivisionLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMicromapVersionInfoEXT(ApiDumpInstance& api_dump, const VkMicromapVersionInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pVersionData, 2 * VK_UUID_SIZE, "const uint8_t*", "pVersionData", "const uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint8_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMicromapToMemoryInfoEXT(ApiDumpInstance& api_dump, const VkCopyMicromapToMemoryInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.src, "VkMicromapEXT", "src", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressKHR(api_dump, object.dst, "VkDeviceOrHostAddressKHR", "dst", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCopyMicromapModeEXT(api_dump, object.mode, "VkCopyMicromapModeEXT", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryToMicromapInfoEXT(ApiDumpInstance& api_dump, const VkCopyMemoryToMicromapInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.src, "VkDeviceOrHostAddressConstKHR", "src", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.dst, "VkMicromapEXT", "dst", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCopyMicromapModeEXT(api_dump, object.mode, "VkCopyMicromapModeEXT", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMicromapInfoEXT(ApiDumpInstance& api_dump, const VkCopyMicromapInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.src, "VkMicromapEXT", "src", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.dst, "VkMicromapEXT", "dst", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCopyMicromapModeEXT(api_dump, object.mode, "VkCopyMicromapModeEXT", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMicromapBuildSizesInfoEXT(ApiDumpInstance& api_dump, const VkMicromapBuildSizesInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.micromapSize, "VkDeviceSize", "micromapSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.buildScratchSize, "VkDeviceSize", "buildScratchSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.discardable, "VkBool32", "discardable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureTrianglesOpacityMicromapEXT(ApiDumpInstance& api_dump, const VkAccelerationStructureTrianglesOpacityMicromapEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.indexBuffer, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indexStride, "VkDeviceSize", "indexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseTriangle, "uint32_t", "baseTriangle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.usageCountsCount, "uint32_t", "usageCountsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pUsageCounts, object.usageCountsCount, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT);
+    dump_separate_members(api_dump);
+    dump_double_pointer_array(api_dump, object.ppUsageCounts, object.usageCountsCount * 1, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT);
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.micromap, "VkMicromapEXT", "micromap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMicromapTriangleEXT(ApiDumpInstance& api_dump, const VkMicromapTriangleEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.dataOffset, "uint32_t", "dataOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.subdivisionLevel, "uint16_t", "subdivisionLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.format, "uint16_t", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceDisplacementMicromapFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDisplacementMicromapFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.displacementMicromap, "VkBool32", "displacementMicromap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDisplacementMicromapPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDisplacementMicromapPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDisplacementMicromapSubdivisionLevel, "uint32_t", "maxDisplacementMicromapSubdivisionLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureTrianglesDisplacementMicromapNV(ApiDumpInstance& api_dump, const VkAccelerationStructureTrianglesDisplacementMicromapNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.displacementBiasAndScaleFormat, "VkFormat", "displacementBiasAndScaleFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.displacementVectorFormat, "VkFormat", "displacementVectorFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.displacementBiasAndScaleBuffer, "VkDeviceOrHostAddressConstKHR", "displacementBiasAndScaleBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.displacementBiasAndScaleStride, "VkDeviceSize", "displacementBiasAndScaleStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.displacementVectorBuffer, "VkDeviceOrHostAddressConstKHR", "displacementVectorBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.displacementVectorStride, "VkDeviceSize", "displacementVectorStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.displacedMicromapPrimitiveFlags, "VkDeviceOrHostAddressConstKHR", "displacedMicromapPrimitiveFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.displacedMicromapPrimitiveFlagsStride, "VkDeviceSize", "displacedMicromapPrimitiveFlagsStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.indexBuffer, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indexStride, "VkDeviceSize", "indexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.baseTriangle, "uint32_t", "baseTriangle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.usageCountsCount, "uint32_t", "usageCountsCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pUsageCounts, object.usageCountsCount, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT);
+    dump_separate_members(api_dump);
+    dump_double_pointer_array(api_dump, object.ppUsageCounts, object.usageCountsCount * 1, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT);
+    dump_separate_members(api_dump);
+    dump_VkMicromapEXT(api_dump, object.micromap, "VkMicromapEXT", "micromap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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_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, "VkMemoryDecompressionMethodFlagsNV", "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);
+void dump_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.clustercullingShader, "VkBool32", "clustercullingShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewClusterCullingShader, "VkBool32", "multiviewClusterCullingShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxWorkGroupCount, 3, "uint32_t[3]", "maxWorkGroupCount", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxWorkGroupSize, 3, "uint32_t[3]", "maxWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxOutputClusterCount, "uint32_t", "maxOutputClusterCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indirectBufferOffsetAlignment, "VkDeviceSize", "indirectBufferOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.clusterShadingRate, "VkBool32", "clusterShadingRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.borderColorSwizzle, "VkBool32", "borderColorSwizzle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.borderColorSwizzleFromImage, "VkBool32", "borderColorSwizzleFromImage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerBorderColorComponentMappingCreateInfoEXT(ApiDumpInstance& api_dump, const VkSamplerBorderColorComponentMappingCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.components, "VkComponentMapping", "components", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.srgb, "VkBool32", "srgb", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pageableDeviceLocalMemory, "VkBool32", "pageableDeviceLocalMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderCorePropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderCorePropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pixelRate, "uint32_t", "pixelRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.texelRate, "uint32_t", "texelRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.fmaRate, "uint32_t", "fmaRate", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceQueueShaderCoreControlCreateInfoARM(ApiDumpInstance& api_dump, const VkDeviceQueueShaderCoreControlCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderCoreCount, "uint32_t", "shaderCoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSchedulingControlsFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceSchedulingControlsFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.schedulingControls, "VkBool32", "schedulingControls", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSchedulingControlsPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceSchedulingControlsPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceSchedulingControlsFlagsARM(api_dump, object.schedulingControlsFlags, "VkPhysicalDeviceSchedulingControlsFlagsARM", "schedulingControlsFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageSlicedViewOf3D, "VkBool32", "imageSlicedViewOf3D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewSlicedCreateInfoEXT(ApiDumpInstance& api_dump, const VkImageViewSlicedCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sliceOffset, "uint32_t", "sliceOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.sliceCount, "uint32_t", "sliceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorSetHostMapping, "VkBool32", "descriptorSetHostMapping", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetBindingReferenceVALVE(ApiDumpInstance& api_dump, const VkDescriptorSetBindingReferenceVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDescriptorSetLayout(api_dump, object.descriptorSetLayout, "VkDescriptorSetLayout", "descriptorSetLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance& api_dump, const VkDescriptorSetLayoutHostMappingInfoVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.descriptorOffset, "size_t", "descriptorOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorSize, "uint32_t", "descriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nonSeamlessCubeMap, "VkBool32", "nonSeamlessCubeMap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRenderPassStripedFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceRenderPassStripedFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.renderPassStriped, "VkBool32", "renderPassStriped", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRenderPassStripedPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceRenderPassStripedPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.renderPassStripeGranularity, "VkExtent2D", "renderPassStripeGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRenderPassStripes, "uint32_t", "maxRenderPassStripes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassStripeInfoARM(ApiDumpInstance& api_dump, const VkRenderPassStripeInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRect2D(api_dump, object.stripeArea, "VkRect2D", "stripeArea", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassStripeBeginInfoARM(ApiDumpInstance& api_dump, const VkRenderPassStripeBeginInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stripeInfoCount, "uint32_t", "stripeInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStripeInfos, object.stripeInfoCount, "const VkRenderPassStripeInfoARM*", "pStripeInfos", "const VkRenderPassStripeInfoARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassStripeInfoARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassStripeSubmitInfoARM(ApiDumpInstance& api_dump, const VkRenderPassStripeSubmitInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stripeSemaphoreInfoCount, "uint32_t", "stripeSemaphoreInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStripeSemaphoreInfos, object.stripeSemaphoreInfoCount, "const VkSemaphoreSubmitInfo*", "pStripeSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityMapOffset, "VkBool32", "fragmentDensityMapOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.fragmentDensityOffsetGranularity, "VkExtent2D", "fragmentDensityOffsetGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassFragmentDensityMapOffsetEndInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.fragmentDensityOffsetCount, "uint32_t", "fragmentDensityOffsetCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pFragmentDensityOffsets, object.fragmentDensityOffsetCount, "const VkOffset2D*", "pFragmentDensityOffsets", "const VkOffset2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.indirectCopy, "VkBool32", "indirectCopy", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDecompressMemoryRegionNV(ApiDumpInstance& api_dump, const VkDecompressMemoryRegionNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcAddress, "VkDeviceAddress", "srcAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.dstAddress, "VkDeviceAddress", "dstAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.compressedSize, "VkDeviceSize", "compressedSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.decompressedSize, "VkDeviceSize", "decompressedSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryDecompressionMethodFlagsEXT(api_dump, object.decompressionMethod, "VkMemoryDecompressionMethodFlagsNV", "decompressionMethod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMemoryDecompressionFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMemoryDecompressionFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.memoryDecompression, "VkBool32", "memoryDecompression", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMemoryDecompressionPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMemoryDecompressionPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryDecompressionMethodFlagsEXT(api_dump, object.decompressionMethods, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethods", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxDecompressionIndirectCount, "uint64_t", "maxDecompressionIndirectCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedCompute, "VkBool32", "deviceGeneratedCompute", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedComputePipelines, "VkBool32", "deviceGeneratedComputePipelines", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedComputeCaptureReplay, "VkBool32", "deviceGeneratedComputeCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkComputePipelineIndirectBufferInfoNV(ApiDumpInstance& api_dump, const VkComputePipelineIndirectBufferInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.pipelineDeviceAddressCaptureReplay, "VkDeviceAddress", "pipelineDeviceAddressCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineIndirectDeviceAddressInfoNV(ApiDumpInstance& api_dump, const VkPipelineIndirectDeviceAddressInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineBindPoint(api_dump, object.pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindPipelineIndirectCommandNV(ApiDumpInstance& api_dump, const VkBindPipelineIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.pipelineAddress, "VkDeviceAddress", "pipelineAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.spheres, "VkBool32", "spheres", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.linearSweptSpheres, "VkBool32", "linearSweptSpheres", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryLinearSweptSpheresDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.vertexFormat, "VkFormat", "vertexFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.vertexData, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.vertexStride, "VkDeviceSize", "vertexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.radiusFormat, "VkFormat", "radiusFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.radiusData, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.radiusStride, "VkDeviceSize", "radiusStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.indexData, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indexStride, "VkDeviceSize", "indexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRayTracingLssIndexingModeNV(api_dump, object.indexingMode, "VkRayTracingLssIndexingModeNV", "indexingMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRayTracingLssPrimitiveEndCapsModeNV(api_dump, object.endCapsMode, "VkRayTracingLssPrimitiveEndCapsModeNV", "endCapsMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometrySpheresDataNV(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometrySpheresDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.vertexFormat, "VkFormat", "vertexFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.vertexData, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.vertexStride, "VkDeviceSize", "vertexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.radiusFormat, "VkFormat", "radiusFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.radiusData, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.radiusStride, "VkDeviceSize", "radiusStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.indexData, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indexStride, "VkDeviceSize", "indexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceLinearColorAttachmentFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.linearColorAttachment, "VkBool32", "linearColorAttachment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageCompressionControlSwapchain, "VkBool32", "imageCompressionControlSwapchain", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageViewSampleWeightCreateInfoQCOM(ApiDumpInstance& api_dump, const VkImageViewSampleWeightCreateInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.filterCenter, "VkOffset2D", "filterCenter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.filterSize, "VkExtent2D", "filterSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numPhases, "uint32_t", "numPhases", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageProcessingFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageProcessingFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureSampleWeighted, "VkBool32", "textureSampleWeighted", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureBoxFilter, "VkBool32", "textureBoxFilter", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureBlockMatch, "VkBool32", "textureBlockMatch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageProcessingPropertiesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageProcessingPropertiesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxWeightFilterPhases, "uint32_t", "maxWeightFilterPhases", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxWeightFilterDimension, "VkExtent2D", "maxWeightFilterDimension", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxBlockMatchRegion, "VkExtent2D", "maxBlockMatchRegion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxBoxFilterBlockSize, "VkExtent2D", "maxBoxFilterBlockSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceNestedCommandBufferFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nestedCommandBuffer, "VkBool32", "nestedCommandBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nestedCommandBufferRendering, "VkBool32", "nestedCommandBufferRendering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nestedCommandBufferSimultaneousUse, "VkBool32", "nestedCommandBufferSimultaneousUse", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceNestedCommandBufferPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCommandBufferNestingLevel, "uint32_t", "maxCommandBufferNestingLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkNativeBufferUsageOHOS(ApiDumpInstance& api_dump, const VkNativeBufferUsageOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.OHOSNativeBufferUsage, "uint64_t", "OHOSNativeBufferUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkNativeBufferPropertiesOHOS(ApiDumpInstance& api_dump, const VkNativeBufferPropertiesOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.allocationSize, "VkDeviceSize", "allocationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkNativeBufferFormatPropertiesOHOS(ApiDumpInstance& api_dump, const VkNativeBufferFormatPropertiesOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.formatFeatures, "VkFormatFeatureFlags", "formatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.samplerYcbcrConversionComponents, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrModelConversion(api_dump, object.suggestedYcbcrModel, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrRange(api_dump, object.suggestedYcbcrRange, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedXChromaOffset, "VkChromaLocation", "suggestedXChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedYChromaOffset, "VkChromaLocation", "suggestedYChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportNativeBufferInfoOHOS(ApiDumpInstance& api_dump, const VkImportNativeBufferInfoOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct OH_NativeBuffer*>(api_dump, object.buffer, "struct OH_NativeBuffer*", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetNativeBufferInfoOHOS(ApiDumpInstance& api_dump, const VkMemoryGetNativeBufferInfoOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalFormatOHOS(ApiDumpInstance& api_dump, const VkExternalFormatOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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<Format>(object.pTensorMemoryBarriers, settings, "const VkTensorMemoryBarrierARM*", "pTensorMemoryBarriers", 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);
+void dump_VkExternalMemoryAcquireUnmodifiedEXT(ApiDumpInstance& api_dump, const VkExternalMemoryAcquireUnmodifiedEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.acquireUnmodifiedMemory, "VkBool32", "acquireUnmodifiedMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3TessellationDomainOrigin, "VkBool32", "extendedDynamicState3TessellationDomainOrigin", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3DepthClampEnable, "VkBool32", "extendedDynamicState3DepthClampEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3PolygonMode, "VkBool32", "extendedDynamicState3PolygonMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3RasterizationSamples, "VkBool32", "extendedDynamicState3RasterizationSamples", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3SampleMask, "VkBool32", "extendedDynamicState3SampleMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3AlphaToCoverageEnable, "VkBool32", "extendedDynamicState3AlphaToCoverageEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3AlphaToOneEnable, "VkBool32", "extendedDynamicState3AlphaToOneEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3LogicOpEnable, "VkBool32", "extendedDynamicState3LogicOpEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ColorBlendEnable, "VkBool32", "extendedDynamicState3ColorBlendEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ColorBlendEquation, "VkBool32", "extendedDynamicState3ColorBlendEquation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ColorWriteMask, "VkBool32", "extendedDynamicState3ColorWriteMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3RasterizationStream, "VkBool32", "extendedDynamicState3RasterizationStream", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ConservativeRasterizationMode, "VkBool32", "extendedDynamicState3ConservativeRasterizationMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ExtraPrimitiveOverestimationSize, "VkBool32", "extendedDynamicState3ExtraPrimitiveOverestimationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3DepthClipEnable, "VkBool32", "extendedDynamicState3DepthClipEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3SampleLocationsEnable, "VkBool32", "extendedDynamicState3SampleLocationsEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ColorBlendAdvanced, "VkBool32", "extendedDynamicState3ColorBlendAdvanced", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ProvokingVertexMode, "VkBool32", "extendedDynamicState3ProvokingVertexMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3LineRasterizationMode, "VkBool32", "extendedDynamicState3LineRasterizationMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3LineStippleEnable, "VkBool32", "extendedDynamicState3LineStippleEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3DepthClipNegativeOneToOne, "VkBool32", "extendedDynamicState3DepthClipNegativeOneToOne", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ViewportWScalingEnable, "VkBool32", "extendedDynamicState3ViewportWScalingEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ViewportSwizzle, "VkBool32", "extendedDynamicState3ViewportSwizzle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3CoverageToColorEnable, "VkBool32", "extendedDynamicState3CoverageToColorEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3CoverageToColorLocation, "VkBool32", "extendedDynamicState3CoverageToColorLocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3CoverageModulationMode, "VkBool32", "extendedDynamicState3CoverageModulationMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3CoverageModulationTableEnable, "VkBool32", "extendedDynamicState3CoverageModulationTableEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3CoverageModulationTable, "VkBool32", "extendedDynamicState3CoverageModulationTable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3CoverageReductionMode, "VkBool32", "extendedDynamicState3CoverageReductionMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3RepresentativeFragmentTestEnable, "VkBool32", "extendedDynamicState3RepresentativeFragmentTestEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedDynamicState3ShadingRateImageEnable, "VkBool32", "extendedDynamicState3ShadingRateImageEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicPrimitiveTopologyUnrestricted, "VkBool32", "dynamicPrimitiveTopologyUnrestricted", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkColorBlendEquationEXT(ApiDumpInstance& api_dump, const VkColorBlendEquationEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkBlendFactor(api_dump, object.srcColorBlendFactor, "VkBlendFactor", "srcColorBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.dstColorBlendFactor, "VkBlendFactor", "dstColorBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendOp(api_dump, object.colorBlendOp, "VkBlendOp", "colorBlendOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.srcAlphaBlendFactor, "VkBlendFactor", "srcAlphaBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendFactor(api_dump, object.dstAlphaBlendFactor, "VkBlendFactor", "dstAlphaBlendFactor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendOp(api_dump, object.alphaBlendOp, "VkBlendOp", "alphaBlendOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkColorBlendAdvancedEXT(ApiDumpInstance& api_dump, const VkColorBlendAdvancedEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkBlendOp(api_dump, object.advancedBlendOp, "VkBlendOp", "advancedBlendOp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.srcPremultiplied, "VkBool32", "srcPremultiplied", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dstPremultiplied, "VkBool32", "dstPremultiplied", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlendOverlapEXT(api_dump, object.blendOverlap, "VkBlendOverlapEXT", "blendOverlap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.clampResults, "VkBool32", "clampResults", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.subpassMergeFeedback, "VkBool32", "subpassMergeFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassCreationControlEXT(ApiDumpInstance& api_dump, const VkRenderPassCreationControlEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.disallowMerging, "VkBool32", "disallowMerging", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassCreationFeedbackInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassCreationFeedbackInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.postMergeSubpassCount, "uint32_t", "postMergeSubpassCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassCreationFeedbackCreateInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassCreationFeedbackCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pRenderPassFeedback, "VkRenderPassCreationFeedbackInfoEXT*", "pRenderPassFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassCreationFeedbackInfoEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassSubpassFeedbackInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassSubpassFeedbackInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkSubpassMergeStatusEXT(api_dump, object.subpassMergeStatus, "VkSubpassMergeStatusEXT", "subpassMergeStatus", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.description, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.postMergeIndex, "uint32_t", "postMergeIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassSubpassFeedbackCreateInfoEXT(ApiDumpInstance& api_dump, const VkRenderPassSubpassFeedbackCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSubpassFeedback, "VkRenderPassSubpassFeedbackInfoEXT*", "pSubpassFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassSubpassFeedbackInfoEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDirectDriverLoadingInfoLUNARG(ApiDumpInstance& api_dump, const VkDirectDriverLoadingInfoLUNARG& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDirectDriverLoadingFlagsLUNARG(api_dump, object.flags, "VkDirectDriverLoadingFlagsLUNARG", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_PFN_vkGetInstanceProcAddrLUNARG(api_dump, object.pfnGetInstanceProcAddr, "PFN_vkGetInstanceProcAddrLUNARG", "pfnGetInstanceProcAddr", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDirectDriverLoadingListLUNARG(ApiDumpInstance& api_dump, const VkDirectDriverLoadingListLUNARG& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDirectDriverLoadingModeLUNARG(api_dump, object.mode, "VkDirectDriverLoadingModeLUNARG", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.driverCount, "uint32_t", "driverCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDrivers, object.driverCount, "const VkDirectDriverLoadingInfoLUNARG*", "pDrivers", "const VkDirectDriverLoadingInfoLUNARG", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDirectDriverLoadingInfoLUNARG);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorDescriptionARM(ApiDumpInstance& api_dump, const VkTensorDescriptionARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorTilingARM(api_dump, object.tiling, "VkTensorTilingARM", "tiling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dimensionCount, "uint32_t", "dimensionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDimensions, object.dimensionCount, "const int64_t*", "pDimensions", "const int64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const int64_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStrides, object.dimensionCount, "const int64_t*", "pStrides", "const int64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const int64_t>);
+    dump_separate_members(api_dump);
+    dump_VkTensorUsageFlagsARM(api_dump, object.usage, "VkTensorUsageFlagsARM", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorCreateInfoARM(ApiDumpInstance& api_dump, const VkTensorCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorCreateFlagsARM(api_dump, object.flags, "VkTensorCreateFlagsARM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDescription, "const VkTensorDescriptionARM*", "pDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorDescriptionARM);
+    dump_separate_members(api_dump);
+    dump_VkSharingMode(api_dump, object.sharingMode, "VkSharingMode", "sharingMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndexCount, "uint32_t", "queueFamilyIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pQueueFamilyIndices, object.queueFamilyIndexCount, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorMemoryRequirementsInfoARM(ApiDumpInstance& api_dump, const VkTensorMemoryRequirementsInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.tensor, "VkTensorARM", "tensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindTensorMemoryInfoARM(ApiDumpInstance& api_dump, const VkBindTensorMemoryInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.tensor, "VkTensorARM", "tensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteDescriptorSetTensorARM(ApiDumpInstance& api_dump, const VkWriteDescriptorSetTensorARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tensorViewCount, "uint32_t", "tensorViewCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTensorViews, object.tensorViewCount, "const VkTensorViewARM*", "pTensorViews", "const VkTensorViewARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorViewARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorFormatPropertiesARM(ApiDumpInstance& api_dump, const VkTensorFormatPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.optimalTilingTensorFeatures, "VkFormatFeatureFlags2", "optimalTilingTensorFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags2(api_dump, object.linearTilingTensorFeatures, "VkFormatFeatureFlags2", "linearTilingTensorFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTensorPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTensorPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTensorDimensionCount, "uint32_t", "maxTensorDimensionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxTensorElements, "uint64_t", "maxTensorElements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxPerDimensionTensorElements, "uint64_t", "maxPerDimensionTensorElements", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int64_t>(api_dump, object.maxTensorStride, "int64_t", "maxTensorStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxTensorSize, "uint64_t", "maxTensorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTensorShaderAccessArrayLength, "uint32_t", "maxTensorShaderAccessArrayLength", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTensorShaderAccessSize, "uint32_t", "maxTensorShaderAccessSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetStorageTensors, "uint32_t", "maxDescriptorSetStorageTensors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorSetStorageTensors, "uint32_t", "maxPerStageDescriptorSetStorageTensors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindStorageTensors, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageTensors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindStorageTensors, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageTensors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTensorArrayNonUniformIndexingNative, "VkBool32", "shaderStorageTensorArrayNonUniformIndexingNative", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.shaderTensorSupportedStages, "VkShaderStageFlags", "shaderTensorSupportedStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorMemoryBarrierARM(ApiDumpInstance& api_dump, const VkTensorMemoryBarrierARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.srcStageMask, "VkPipelineStageFlags2", "srcStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.srcAccessMask, "VkAccessFlags2", "srcAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineStageFlags2(api_dump, object.dstStageMask, "VkPipelineStageFlags2", "dstStageMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccessFlags2(api_dump, object.dstAccessMask, "VkAccessFlags2", "dstAccessMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.srcQueueFamilyIndex, "uint32_t", "srcQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dstQueueFamilyIndex, "uint32_t", "dstQueueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.tensor, "VkTensorARM", "tensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorDependencyInfoARM(ApiDumpInstance& api_dump, const VkTensorDependencyInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tensorMemoryBarrierCount, "uint32_t", "tensorMemoryBarrierCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTensorMemoryBarriers, "const VkTensorMemoryBarrierARM*", "pTensorMemoryBarriers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorMemoryBarrierARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTensorFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTensorFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tensorNonPacked, "VkBool32", "tensorNonPacked", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderTensorAccess, "VkBool32", "shaderTensorAccess", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTensorArrayDynamicIndexing, "VkBool32", "shaderStorageTensorArrayDynamicIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderStorageTensorArrayNonUniformIndexing, "VkBool32", "shaderStorageTensorArrayNonUniformIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingStorageTensorUpdateAfterBind, "VkBool32", "descriptorBindingStorageTensorUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tensors, "VkBool32", "tensors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDeviceTensorMemoryRequirementsARM(ApiDumpInstance& api_dump, const VkDeviceTensorMemoryRequirementsARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCreateInfo, "const VkTensorCreateInfoARM*", "pCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorCreateInfoARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorCopyARM(ApiDumpInstance& api_dump, const VkTensorCopyARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dimensionCount, "uint32_t", "dimensionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSrcOffset, object.dimensionCount, "const uint64_t*", "pSrcOffset", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pDstOffset, object.dimensionCount, "const uint64_t*", "pDstOffset", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pExtent, object.dimensionCount, "const uint64_t*", "pExtent", "const uint64_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint64_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyTensorInfoARM(ApiDumpInstance& api_dump, const VkCopyTensorInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.srcTensor, "VkTensorARM", "srcTensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.dstTensor, "VkTensorARM", "dstTensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkTensorCopyARM*", "pRegions", "const VkTensorCopyARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorCopyARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryDedicatedAllocateInfoTensorARM(ApiDumpInstance& api_dump, const VkMemoryDedicatedAllocateInfoTensorARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.tensor, "VkTensorARM", "tensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalTensorInfoARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalTensorInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorCreateFlagsARM(api_dump, object.flags, "VkTensorCreateFlagsARM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDescription, "const VkTensorDescriptionARM*", "pDescription", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorDescriptionARM);
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalTensorPropertiesARM(ApiDumpInstance& api_dump, const VkExternalTensorPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryProperties(api_dump, object.externalMemoryProperties, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalMemoryTensorCreateInfoARM(ApiDumpInstance& api_dump, const VkExternalMemoryTensorCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.handleTypes, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBufferTensorDescriptors, "VkBool32", "descriptorBufferTensorDescriptors", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tensorCaptureReplayDescriptorDataSize, "size_t", "tensorCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tensorViewCaptureReplayDescriptorDataSize, "size_t", "tensorViewCaptureReplayDescriptorDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.tensorDescriptorSize, "size_t", "tensorDescriptorSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDescriptorGetTensorInfoARM(ApiDumpInstance& api_dump, const VkDescriptorGetTensorInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorViewARM(api_dump, object.tensorView, "VkTensorViewARM", "tensorView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorCaptureDescriptorDataInfoARM(ApiDumpInstance& api_dump, const VkTensorCaptureDescriptorDataInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorARM(api_dump, object.tensor, "VkTensorARM", "tensor", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTensorViewCaptureDescriptorDataInfoARM(ApiDumpInstance& api_dump, const VkTensorViewCaptureDescriptorDataInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkTensorViewARM(api_dump, object.tensorView, "VkTensorViewARM", "tensorView", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkFrameBoundaryTensorsARM(ApiDumpInstance& api_dump, const VkFrameBoundaryTensorsARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tensorCount, "uint32_t", "tensorCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTensors, object.tensorCount, "const VkTensorARM*", "pTensors", "const VkTensorARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderModuleIdentifier, "VkBool32", "shaderModuleIdentifier", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "shaderModuleIdentifierAlgorithmUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineShaderStageModuleIdentifierCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.identifierSize, "uint32_t", "identifierSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pIdentifier, object.identifierSize, "const uint8_t*", "pIdentifier", "const uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint8_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderModuleIdentifierEXT(ApiDumpInstance& api_dump, const VkShaderModuleIdentifierEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.identifierSize, "uint32_t", "identifierSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.identifier, std::min(object.identifierSize, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT), "uint8_t[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]", "identifier", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceOpticalFlowFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceOpticalFlowFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.opticalFlow, "VkBool32", "opticalFlow", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceOpticalFlowPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceOpticalFlowPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowGridSizeFlagsNV(api_dump, object.supportedOutputGridSizes, "VkOpticalFlowGridSizeFlagsNV", "supportedOutputGridSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowGridSizeFlagsNV(api_dump, object.supportedHintGridSizes, "VkOpticalFlowGridSizeFlagsNV", "supportedHintGridSizes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hintSupported, "VkBool32", "hintSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.costSupported, "VkBool32", "costSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.bidirectionalFlowSupported, "VkBool32", "bidirectionalFlowSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.globalFlowSupported, "VkBool32", "globalFlowSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minWidth, "uint32_t", "minWidth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minHeight, "uint32_t", "minHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxWidth, "uint32_t", "maxWidth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxHeight, "uint32_t", "maxHeight", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxNumRegionsOfInterest, "uint32_t", "maxNumRegionsOfInterest", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpticalFlowImageFormatInfoNV(ApiDumpInstance& api_dump, const VkOpticalFlowImageFormatInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowUsageFlagsNV(api_dump, object.usage, "VkOpticalFlowUsageFlagsNV", "usage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpticalFlowImageFormatPropertiesNV(ApiDumpInstance& api_dump, const VkOpticalFlowImageFormatPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpticalFlowSessionCreateInfoNV(ApiDumpInstance& api_dump, const VkOpticalFlowSessionCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.imageFormat, "VkFormat", "imageFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.flowVectorFormat, "VkFormat", "flowVectorFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.costFormat, "VkFormat", "costFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowGridSizeFlagsNV(api_dump, object.outputGridSize, "VkOpticalFlowGridSizeFlagsNV", "outputGridSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowGridSizeFlagsNV(api_dump, object.hintGridSize, "VkOpticalFlowGridSizeFlagsNV", "hintGridSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowPerformanceLevelNV(api_dump, object.performanceLevel, "VkOpticalFlowPerformanceLevelNV", "performanceLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowSessionCreateFlagsNV(api_dump, object.flags, "VkOpticalFlowSessionCreateFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpticalFlowSessionCreatePrivateDataInfoNV(ApiDumpInstance& api_dump, const VkOpticalFlowSessionCreatePrivateDataInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.id, "uint32_t", "id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pPrivateData, "const void*", "pPrivateData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOpticalFlowExecuteInfoNV(ApiDumpInstance& api_dump, const VkOpticalFlowExecuteInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOpticalFlowExecuteFlagsNV(api_dump, object.flags, "VkOpticalFlowExecuteFlagsNV", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkRect2D*", "pRegions", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLegacyDitheringFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceLegacyDitheringFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.legacyDithering, "VkBool32", "legacyDithering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.externalFormatResolve, "VkBool32", "externalFormatResolve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nullColorAttachmentWithExternalFormatResolve, "VkBool32", "nullColorAttachmentWithExternalFormatResolve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.externalFormatResolveChromaOffsetX, "VkChromaLocation", "externalFormatResolveChromaOffsetX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.externalFormatResolveChromaOffsetY, "VkChromaLocation", "externalFormatResolveChromaOffsetY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(ApiDumpInstance& api_dump, const VkAndroidHardwareBufferFormatResolvePropertiesANDROID& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.colorAttachmentFormat, "VkFormat", "colorAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceAntiLagFeaturesAMD(ApiDumpInstance& api_dump, const VkPhysicalDeviceAntiLagFeaturesAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.antiLag, "VkBool32", "antiLag", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAntiLagPresentationInfoAMD(ApiDumpInstance& api_dump, const VkAntiLagPresentationInfoAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAntiLagStageAMD(api_dump, object.stage, "VkAntiLagStageAMD", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.frameIndex, "uint64_t", "frameIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAntiLagDataAMD(ApiDumpInstance& api_dump, const VkAntiLagDataAMD& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAntiLagModeAMD(api_dump, object.mode, "VkAntiLagModeAMD", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFPS, "uint32_t", "maxFPS", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pPresentationInfo, "const VkAntiLagPresentationInfoAMD*", "pPresentationInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAntiLagPresentationInfoAMD);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(ApiDumpInstance& api_dump, const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.denseGeometryFormat, "VkBool32", "denseGeometryFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(ApiDumpInstance& api_dump, const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.compressedData, "VkDeviceOrHostAddressConstKHR", "compressedData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.dataSize, "VkDeviceSize", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numTriangles, "uint32_t", "numTriangles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numVertices, "uint32_t", "numVertices", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPrimitiveIndex, "uint32_t", "maxPrimitiveIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryIndex, "uint32_t", "maxGeometryIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCompressedTriangleFormatAMDX(api_dump, object.format, "VkCompressedTriangleFormatAMDX", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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));
+void dump_VkPhysicalDeviceShaderObjectFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderObjectFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderObject, "VkBool32", "shaderObject", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderObjectPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderObjectPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.shaderBinaryUUID, VK_UUID_SIZE, "uint8_t[VK_UUID_SIZE]", "shaderBinaryUUID", "uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderBinaryVersion, "uint32_t", "shaderBinaryVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkShaderCreateInfoEXT(ApiDumpInstance& api_dump, const VkShaderCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderCreateFlagsEXT(api_dump, object.flags, "VkShaderCreateFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlagBits(api_dump, object.stage, "VkShaderStageFlagBits", "stage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.nextStage, "VkShaderStageFlags", "nextStage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderCodeTypeEXT(api_dump, object.codeType, "VkShaderCodeTypeEXT", "codeType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.codeSize, "size_t", "codeSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+
+    if (api_dump.settings().showShader()) {
+        dump_spirv(api_dump, object.pCode, object.codeSize, "const void*", "pCode", indents + (api_dump.settings().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, "VkPipelineCreateFlags2KHR", "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_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);
+        dump_special(api_dump, "SHADER DATA", "const void*", "pCode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    }
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pName, "const char*", "pName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.setLayoutCount, "uint32_t", "setLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSetLayouts, object.setLayoutCount, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushConstantRangeCount, "uint32_t", "pushConstantRangeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPushConstantRanges, object.pushConstantRangeCount, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSpecializationInfo, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDepthClampRangeEXT(ApiDumpInstance& api_dump, const VkDepthClampRangeEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<float>(api_dump, object.minDepthClamp, "float", "minDepthClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.maxDepthClamp, "float", "maxDepthClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTilePropertiesFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTilePropertiesFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileProperties, "VkBool32", "tileProperties", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTilePropertiesQCOM(ApiDumpInstance& api_dump, const VkTilePropertiesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent3D(api_dump, object.tileSize, "VkExtent3D", "tileSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.apronSize, "VkExtent2D", "apronSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOffset2D(api_dump, object.origin, "VkOffset2D", "origin", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceAmigoProfilingFeaturesSEC(ApiDumpInstance& api_dump, const VkPhysicalDeviceAmigoProfilingFeaturesSEC& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.amigoProfiling, "VkBool32", "amigoProfiling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAmigoProfilingSubmitInfoSEC(ApiDumpInstance& api_dump, const VkAmigoProfilingSubmitInfoSEC& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.firstDrawTimestamp, "uint64_t", "firstDrawTimestamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.swapBufferTimestamp, "uint64_t", "swapBufferTimestamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewPerViewViewports, "VkBool32", "multiviewPerViewViewports", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRayTracingInvocationReorderModeEXT(api_dump, object.rayTracingInvocationReorderReorderingHint, "VkRayTracingInvocationReorderModeEXT", "rayTracingInvocationReorderReorderingHint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingInvocationReorder, "VkBool32", "rayTracingInvocationReorder", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeVectorPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.cooperativeVectorSupportedStages, "VkShaderStageFlags", "cooperativeVectorSupportedStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeVectorTrainingFloat16Accumulation, "VkBool32", "cooperativeVectorTrainingFloat16Accumulation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeVectorTrainingFloat32Accumulation, "VkBool32", "cooperativeVectorTrainingFloat32Accumulation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxCooperativeVectorComponents, "uint32_t", "maxCooperativeVectorComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeVectorFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeVectorFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeVector, "VkBool32", "cooperativeVector", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeVectorTraining, "VkBool32", "cooperativeVectorTraining", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCooperativeVectorPropertiesNV(ApiDumpInstance& api_dump, const VkCooperativeVectorPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.inputType, "VkComponentTypeKHR", "inputType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.inputInterpretation, "VkComponentTypeKHR", "inputInterpretation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.matrixInterpretation, "VkComponentTypeKHR", "matrixInterpretation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.biasInterpretation, "VkComponentTypeKHR", "biasInterpretation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.resultType, "VkComponentTypeKHR", "resultType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.transpose, "VkBool32", "transpose", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkConvertCooperativeVectorMatrixInfoNV(ApiDumpInstance& api_dump, const VkConvertCooperativeVectorMatrixInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.srcSize, "size_t", "srcSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.srcData, "VkDeviceOrHostAddressConstKHR", "srcData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDstSize, "size_t*", "pDstSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<size_t>);
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressKHR(api_dump, object.dstData, "VkDeviceOrHostAddressKHR", "dstData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.srcComponentType, "VkComponentTypeKHR", "srcComponentType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.dstComponentType, "VkComponentTypeKHR", "dstComponentType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numRows, "uint32_t", "numRows", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numColumns, "uint32_t", "numColumns", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCooperativeVectorMatrixLayoutNV(api_dump, object.srcLayout, "VkCooperativeVectorMatrixLayoutNV", "srcLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.srcStride, "size_t", "srcStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCooperativeVectorMatrixLayoutNV(api_dump, object.dstLayout, "VkCooperativeVectorMatrixLayoutNV", "dstLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dstStride, "size_t", "dstStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.extendedSparseAddressSpace, "VkBool32", "extendedSparseAddressSpace", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.extendedSparseAddressSpaceSize, "VkDeviceSize", "extendedSparseAddressSpaceSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkImageUsageFlags(api_dump, object.extendedSparseImageUsageFlags, "VkImageUsageFlags", "extendedSparseImageUsageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBufferUsageFlags(api_dump, object.extendedSparseBufferUsageFlags, "VkBufferUsageFlags", "extendedSparseBufferUsageFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.legacyVertexAttributes, "VkBool32", "legacyVertexAttributes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.nativeUnalignedPerformance, "VkBool32", "nativeUnalignedPerformance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLayerSettingEXT(ApiDumpInstance& api_dump, const VkLayerSettingEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_char(api_dump, object.pLayerName, "const char*", "pLayerName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pSettingName, "const char*", "pSettingName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkLayerSettingTypeEXT(api_dump, object.type, "VkLayerSettingTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.valueCount, "uint32_t", "valueCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pValues, "const void*", "pValues", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLayerSettingsCreateInfoEXT(ApiDumpInstance& api_dump, const VkLayerSettingsCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.settingCount, "uint32_t", "settingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSettings, object.settingCount, "const VkLayerSettingEXT*", "pSettings", "const VkLayerSettingEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkLayerSettingEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderCoreBuiltins, "VkBool32", "shaderCoreBuiltins", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.shaderCoreMask, "uint64_t", "shaderCoreMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderCoreCount, "uint32_t", "shaderCoreCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderWarpsPerCore, "uint32_t", "shaderWarpsPerCore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineLibraryGroupHandles, "VkBool32", "pipelineLibraryGroupHandles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicRenderingUnusedAttachments, "VkBool32", "dynamicRenderingUnusedAttachments", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLatencySleepModeInfoNV(ApiDumpInstance& api_dump, const VkLatencySleepModeInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.lowLatencyMode, "VkBool32", "lowLatencyMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.lowLatencyBoost, "VkBool32", "lowLatencyBoost", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minimumIntervalUs, "uint32_t", "minimumIntervalUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLatencySleepInfoNV(ApiDumpInstance& api_dump, const VkLatencySleepInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSemaphore(api_dump, object.signalSemaphore, "VkSemaphore", "signalSemaphore", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.value, "uint64_t", "value", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSetLatencyMarkerInfoNV(ApiDumpInstance& api_dump, const VkSetLatencyMarkerInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentID, "uint64_t", "presentID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkLatencyMarkerNV(api_dump, object.marker, "VkLatencyMarkerNV", "marker", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLatencyTimingsFrameReportNV(ApiDumpInstance& api_dump, const VkLatencyTimingsFrameReportNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentID, "uint64_t", "presentID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.inputSampleTimeUs, "uint64_t", "inputSampleTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.simStartTimeUs, "uint64_t", "simStartTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.simEndTimeUs, "uint64_t", "simEndTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.renderSubmitStartTimeUs, "uint64_t", "renderSubmitStartTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.renderSubmitEndTimeUs, "uint64_t", "renderSubmitEndTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentStartTimeUs, "uint64_t", "presentStartTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentEndTimeUs, "uint64_t", "presentEndTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.driverStartTimeUs, "uint64_t", "driverStartTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.driverEndTimeUs, "uint64_t", "driverEndTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.osRenderQueueStartTimeUs, "uint64_t", "osRenderQueueStartTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.osRenderQueueEndTimeUs, "uint64_t", "osRenderQueueEndTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.gpuRenderStartTimeUs, "uint64_t", "gpuRenderStartTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.gpuRenderEndTimeUs, "uint64_t", "gpuRenderEndTimeUs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGetLatencyMarkerInfoNV(ApiDumpInstance& api_dump, const VkGetLatencyMarkerInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.timingCount, "uint32_t", "timingCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTimings, object.timingCount, "VkLatencyTimingsFrameReportNV*", "pTimings", "VkLatencyTimingsFrameReportNV", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkLatencyTimingsFrameReportNV);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLatencySubmissionPresentIdNV(ApiDumpInstance& api_dump, const VkLatencySubmissionPresentIdNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.presentID, "uint64_t", "presentID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSwapchainLatencyCreateInfoNV(ApiDumpInstance& api_dump, const VkSwapchainLatencyCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.latencyModeEnable, "VkBool32", "latencyModeEnable", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkOutOfBandQueueTypeInfoNV(ApiDumpInstance& api_dump, const VkOutOfBandQueueTypeInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkOutOfBandQueueTypeNV(api_dump, object.queueType, "VkOutOfBandQueueTypeNV", "queueType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkLatencySurfaceCapabilitiesNV(ApiDumpInstance& api_dump, const VkLatencySurfaceCapabilitiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.presentModeCount, "uint32_t", "presentModeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPresentModes, object.presentModeCount, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDataGraphFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDataGraphFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dataGraph, "VkBool32", "dataGraph", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dataGraphUpdateAfterBind, "VkBool32", "dataGraphUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dataGraphSpecializationConstants, "VkBool32", "dataGraphSpecializationConstants", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dataGraphDescriptorBuffer, "VkBool32", "dataGraphDescriptorBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dataGraphShaderModule, "VkBool32", "dataGraphShaderModule", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineConstantARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineConstantARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.id, "uint32_t", "id", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pConstantData, "const void*", "pConstantData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineResourceInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineResourceInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.descriptorSet, "uint32_t", "descriptorSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.binding, "uint32_t", "binding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.arrayElement, "uint32_t", "arrayElement", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineCompilerControlCreateInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineCompilerControlCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pVendorOptions, "const char*", "pVendorOptions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineCreateInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags2(api_dump, object.flags, "VkPipelineCreateFlags2KHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.resourceInfoCount, "uint32_t", "resourceInfoCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pResourceInfos, object.resourceInfoCount, "const VkDataGraphPipelineResourceInfoARM*", "pResourceInfos", "const VkDataGraphPipelineResourceInfoARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineResourceInfoARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineShaderModuleCreateInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineShaderModuleCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderModule(api_dump, object.module, "VkShaderModule", "module", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.pName, "const char*", "pName", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pSpecializationInfo, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.constantCount, "uint32_t", "constantCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pConstants, object.constantCount, "const VkDataGraphPipelineConstantARM*", "pConstants", "const VkDataGraphPipelineConstantARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineConstantARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineSessionCreateInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionCreateFlagsARM(api_dump, object.flags, "VkDataGraphPipelineSessionCreateFlagsARM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.dataGraphPipeline, "VkPipeline", "dataGraphPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionARM(api_dump, object.session, "VkDataGraphPipelineSessionARM", "session", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineSessionBindPointRequirementARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionBindPointRequirementARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionBindPointARM(api_dump, object.bindPoint, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionBindPointTypeARM(api_dump, object.bindPointType, "VkDataGraphPipelineSessionBindPointTypeARM", "bindPointType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numObjects, "uint32_t", "numObjects", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionARM(api_dump, object.session, "VkDataGraphPipelineSessionARM", "session", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionBindPointARM(api_dump, object.bindPoint, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.objectIndex, "uint32_t", "objectIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindDataGraphPipelineSessionMemoryInfoARM(ApiDumpInstance& api_dump, const VkBindDataGraphPipelineSessionMemoryInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionARM(api_dump, object.session, "VkDataGraphPipelineSessionARM", "session", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineSessionBindPointARM(api_dump, object.bindPoint, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.objectIndex, "uint32_t", "objectIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.memoryOffset, "VkDeviceSize", "memoryOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.dataGraphPipeline, "VkPipeline", "dataGraphPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelinePropertyQueryResultARM(ApiDumpInstance& api_dump, const VkDataGraphPipelinePropertyQueryResultARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelinePropertyARM(api_dump, object.property, "VkDataGraphPipelinePropertyARM", "property", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.isText, "VkBool32", "isText", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dataSize, "size_t", "dataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.pData, "void*", "pData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineIdentifierCreateInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineIdentifierCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.identifierSize, "uint32_t", "identifierSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pIdentifier, object.identifierSize, "const uint8_t*", "pIdentifier", "const uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint8_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineDispatchInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineDispatchInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphPipelineDispatchFlagsARM(api_dump, object.flags, "VkDataGraphPipelineDispatchFlagsARM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDataGraphProcessingEngineARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDataGraphProcessingEngineARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(api_dump, object.type, "VkPhysicalDeviceDataGraphProcessingEngineTypeARM", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.isForeign, "VkBool32", "isForeign", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDataGraphOperationSupportARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDataGraphOperationSupportARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPhysicalDeviceDataGraphOperationTypeARM(api_dump, object.operationType, "VkPhysicalDeviceDataGraphOperationTypeARM", "operationType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.version, "uint32_t", "version", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyDataGraphPropertiesARM(ApiDumpInstance& api_dump, const VkQueueFamilyDataGraphPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceDataGraphProcessingEngineARM(api_dump, object.engine, "VkPhysicalDeviceDataGraphProcessingEngineARM", "engine", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceDataGraphOperationSupportARM(api_dump, object.operation, "VkPhysicalDeviceDataGraphOperationSupportARM", "operation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphProcessingEngineCreateInfoARM(ApiDumpInstance& api_dump, const VkDataGraphProcessingEngineCreateInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.processingEngineCount, "uint32_t", "processingEngineCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pProcessingEngines, object.processingEngineCount, "VkPhysicalDeviceDataGraphProcessingEngineARM*", "pProcessingEngines", "VkPhysicalDeviceDataGraphProcessingEngineARM", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceDataGraphProcessingEngineARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.queueFamilyIndex, "uint32_t", "queueFamilyIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(api_dump, object.engineType, "VkPhysicalDeviceDataGraphProcessingEngineTypeARM", "engineType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM(ApiDumpInstance& api_dump, const VkQueueFamilyDataGraphProcessingEnginePropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalSemaphoreHandleTypeFlags(api_dump, object.foreignSemaphoreHandleTypes, "VkExternalSemaphoreHandleTypeFlags", "foreignSemaphoreHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlags(api_dump, object.foreignMemoryHandleTypes, "VkExternalMemoryHandleTypeFlags", "foreignMemoryHandleTypes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(ApiDumpInstance& api_dump, const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.dimension, "uint32_t", "dimension", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.zeroCount, "uint32_t", "zeroCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.groupSize, "uint32_t", "groupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewPerViewRenderAreas, "VkBool32", "multiviewPerViewRenderAreas", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(ApiDumpInstance& api_dump, const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.perViewRenderAreaCount, "uint32_t", "perViewRenderAreaCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPerViewRenderAreas, object.perViewRenderAreaCount, "const VkRect2D*", "pPerViewRenderAreas", "const VkRect2D", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.perStageDescriptorSet, "VkBool32", "perStageDescriptorSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicPipelineLayout, "VkBool32", "dynamicPipelineLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageProcessing2FeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageProcessing2FeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.textureBlockMatch2, "VkBool32", "textureBlockMatch2", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageProcessing2PropertiesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageProcessing2PropertiesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.maxBlockMatchWindow, "VkExtent2D", "maxBlockMatchWindow", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerBlockMatchWindowCreateInfoQCOM(ApiDumpInstance& api_dump, const VkSamplerBlockMatchWindowCreateInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.windowExtent, "VkExtent2D", "windowExtent", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBlockMatchWindowCompareModeQCOM(api_dump, object.windowCompareMode, "VkBlockMatchWindowCompareModeQCOM", "windowCompareMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCubicWeightsFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceCubicWeightsFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.selectableCubicWeights, "VkBool32", "selectableCubicWeights", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerCubicWeightsCreateInfoQCOM(ApiDumpInstance& api_dump, const VkSamplerCubicWeightsCreateInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCubicFilterWeightsQCOM(api_dump, object.cubicWeights, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBlitImageCubicWeightsInfoQCOM(ApiDumpInstance& api_dump, const VkBlitImageCubicWeightsInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCubicFilterWeightsQCOM(api_dump, object.cubicWeights, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.ycbcrDegamma, "VkBool32", "ycbcrDegamma", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(ApiDumpInstance& api_dump, const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.enableYDegamma, "VkBool32", "enableYDegamma", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.enableCbCrDegamma, "VkBool32", "enableCbCrDegamma", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCubicClampFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceCubicClampFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cubicRangeClamp, "VkBool32", "cubicRangeClamp", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.attachmentFeedbackLoopDynamicState, "VkBool32", "attachmentFeedbackLoopDynamicState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkScreenBufferPropertiesQNX(ApiDumpInstance& api_dump, const VkScreenBufferPropertiesQNX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.allocationSize, "VkDeviceSize", "allocationSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkScreenBufferFormatPropertiesQNX(ApiDumpInstance& api_dump, const VkScreenBufferFormatPropertiesQNX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.format, "VkFormat", "format", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.screenUsage, "uint64_t", "screenUsage", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormatFeatureFlags(api_dump, object.formatFeatures, "VkFormatFeatureFlags", "formatFeatures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentMapping(api_dump, object.samplerYcbcrConversionComponents, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrModelConversion(api_dump, object.suggestedYcbcrModel, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSamplerYcbcrRange(api_dump, object.suggestedYcbcrRange, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedXChromaOffset, "VkChromaLocation", "suggestedXChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkChromaLocation(api_dump, object.suggestedYChromaOffset, "VkChromaLocation", "suggestedYChromaOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImportScreenBufferInfoQNX(ApiDumpInstance& api_dump, const VkImportScreenBufferInfoQNX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<struct _screen_buffer*>(api_dump, object.buffer, "struct _screen_buffer*", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalFormatQNX(ApiDumpInstance& api_dump, const VkExternalFormatQNX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.externalFormat, "uint64_t", "externalFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.screenBufferImport, "VkBool32", "screenBufferImport", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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_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);
-    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
-    dump_separate_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);
+void dump_VkPhysicalDeviceLayeredDriverPropertiesMSFT(ApiDumpInstance& api_dump, const VkPhysicalDeviceLayeredDriverPropertiesMSFT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkLayeredDriverUnderlyingApiMSFT(api_dump, object.underlyingAPI, "VkLayeredDriverUnderlyingApiMSFT", "underlyingAPI", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorPoolOverallocation, "VkBool32", "descriptorPoolOverallocation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileMemoryHeap, "VkBool32", "tileMemoryHeap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.queueSubmitBoundary, "VkBool32", "queueSubmitBoundary", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.tileBufferTransfers, "VkBool32", "tileBufferTransfers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTileMemoryRequirementsQCOM(ApiDumpInstance& api_dump, const VkTileMemoryRequirementsQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.alignment, "VkDeviceSize", "alignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTileMemoryBindInfoQCOM(ApiDumpInstance& api_dump, const VkTileMemoryBindInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTileMemorySizeInfoQCOM(ApiDumpInstance& api_dump, const VkTileMemorySizeInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDecompressMemoryRegionEXT(ApiDumpInstance& api_dump, const VkDecompressMemoryRegionEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcAddress, "VkDeviceAddress", "srcAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.dstAddress, "VkDeviceAddress", "dstAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.compressedSize, "VkDeviceSize", "compressedSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.decompressedSize, "VkDeviceSize", "decompressedSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDecompressMemoryInfoEXT(ApiDumpInstance& api_dump, const VkDecompressMemoryInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkMemoryDecompressionMethodFlagsEXT(api_dump, object.decompressionMethod, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionCount, "uint32_t", "regionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pRegions, object.regionCount, "const VkDecompressMemoryRegionEXT*", "pRegions", "const VkDecompressMemoryRegionEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDecompressMemoryRegionEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplaySurfaceStereoCreateInfoNV(ApiDumpInstance& api_dump, const VkDisplaySurfaceStereoCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDisplaySurfaceStereoTypeNV(api_dump, object.stereoType, "VkDisplaySurfaceStereoTypeNV", "stereoType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDisplayModeStereoPropertiesNV(ApiDumpInstance& api_dump, const VkDisplayModeStereoPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hdmi3DSupported, "VkBool32", "hdmi3DSupported", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRawAccessChainsFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRawAccessChainsFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderRawAccessChains, "VkBool32", "shaderRawAccessChains", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalComputeQueueDeviceCreateInfoNV(ApiDumpInstance& api_dump, const VkExternalComputeQueueDeviceCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reservedExternalQueues, "uint32_t", "reservedExternalQueues", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalComputeQueueCreateInfoNV(ApiDumpInstance& api_dump, const VkExternalComputeQueueCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkQueue(api_dump, object.preferredQueue, "VkQueue", "preferredQueue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkExternalComputeQueueDataParamsNV(ApiDumpInstance& api_dump, const VkExternalComputeQueueDataParamsNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.deviceIndex, "uint32_t", "deviceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceExternalComputeQueuePropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceExternalComputeQueuePropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.externalDataSize, "uint32_t", "externalDataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxExternalQueues, "uint32_t", "maxExternalQueues", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.commandBufferInheritance, "VkBool32", "commandBufferInheritance", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloat16VectorAtomics, "VkBool32", "shaderFloat16VectorAtomics", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderReplicatedComposites, "VkBool32", "shaderReplicatedComposites", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderFloat8FeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderFloat8FeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloat8, "VkBool32", "shaderFloat8", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderFloat8CooperativeMatrix, "VkBool32", "shaderFloat8CooperativeMatrix", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingValidationFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingValidationFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingValidation, "VkBool32", "rayTracingValidation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.clusterAccelerationStructure, "VkBool32", "clusterAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVerticesPerCluster, "uint32_t", "maxVerticesPerCluster", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTrianglesPerCluster, "uint32_t", "maxTrianglesPerCluster", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clusterScratchByteAlignment, "uint32_t", "clusterScratchByteAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clusterByteAlignment, "uint32_t", "clusterByteAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clusterTemplateByteAlignment, "uint32_t", "clusterTemplateByteAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clusterBottomLevelByteAlignment, "uint32_t", "clusterBottomLevelByteAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clusterTemplateBoundsByteAlignment, "uint32_t", "clusterTemplateBoundsByteAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxClusterGeometryIndex, "uint32_t", "maxClusterGeometryIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureClustersBottomLevelInputNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureClustersBottomLevelInputNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTotalClusterCount, "uint32_t", "maxTotalClusterCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxClusterCountPerAccelerationStructure, "uint32_t", "maxClusterCountPerAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureTriangleClusterInputNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureTriangleClusterInputNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.vertexFormat, "VkFormat", "vertexFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGeometryIndexValue, "uint32_t", "maxGeometryIndexValue", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxClusterUniqueGeometryCount, "uint32_t", "maxClusterUniqueGeometryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxClusterTriangleCount, "uint32_t", "maxClusterTriangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxClusterVertexCount, "uint32_t", "maxClusterVertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTotalTriangleCount, "uint32_t", "maxTotalTriangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTotalVertexCount, "uint32_t", "maxTotalVertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minPositionTruncateBitCount, "uint32_t", "minPositionTruncateBitCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureMoveObjectsInputNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureMoveObjectsInputNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureTypeNV(api_dump, object.type, "VkClusterAccelerationStructureTypeNV", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.noMoveOverlap, "VkBool32", "noMoveOverlap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.maxMovedBytes, "VkDeviceSize", "maxMovedBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureOpInputNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureOpInputNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_pointer(api_dump, object.pClustersBottomLevel, "VkClusterAccelerationStructureClustersBottomLevelInputNV*", "pClustersBottomLevel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureClustersBottomLevelInputNV);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pTriangleClusters, "VkClusterAccelerationStructureTriangleClusterInputNV*", "pTriangleClusters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureTriangleClusterInputNV);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pMoveObjects, "VkClusterAccelerationStructureMoveObjectsInputNV*", "pMoveObjects", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureMoveObjectsInputNV);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureInputInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureInputInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxAccelerationStructureCount, "uint32_t", "maxAccelerationStructureCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildAccelerationStructureFlagsKHR(api_dump, object.flags, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureOpTypeNV(api_dump, object.opType, "VkClusterAccelerationStructureOpTypeNV", "opType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureOpModeNV(api_dump, object.opMode, "VkClusterAccelerationStructureOpModeNV", "opMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureOpInputNV(api_dump, object.opInput, "VkClusterAccelerationStructureOpInputNV", "opInput", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkStridedDeviceAddressRegionKHR(ApiDumpInstance& api_dump, const VkStridedDeviceAddressRegionKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.stride, "VkDeviceSize", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureCommandsInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureCommandsInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureInputInfoNV(api_dump, object.input, "VkClusterAccelerationStructureInputInfoNV", "input", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.dstImplicitData, "VkDeviceAddress", "dstImplicitData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.scratchData, "VkDeviceAddress", "scratchData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressRegionKHR(api_dump, object.dstAddressesArray, "VkStridedDeviceAddressRegionKHR", "dstAddressesArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressRegionKHR(api_dump, object.dstSizesArray, "VkStridedDeviceAddressRegionKHR", "dstSizesArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressRegionKHR(api_dump, object.srcInfosArray, "VkStridedDeviceAddressRegionKHR", "srcInfosArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcInfosCount, "VkDeviceAddress", "srcInfosCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureAddressResolutionFlagsNV(api_dump, object.addressResolutionFlags, "VkClusterAccelerationStructureAddressResolutionFlagsNV", "addressResolutionFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkStridedDeviceAddressNV(ApiDumpInstance& api_dump, const VkStridedDeviceAddressNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.startAddress, "VkDeviceAddress", "startAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.strideInBytes, "VkDeviceSize", "strideInBytes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.geometryIndex, "uint32_t:24", "geometryIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t:5", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.geometryFlags, "uint32_t:3", "geometryFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureMoveObjectsInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureMoveObjectsInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcAccelerationStructure, "VkDeviceAddress", "srcAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.clusterReferencesCount, "uint32_t", "clusterReferencesCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.clusterReferencesStride, "uint32_t", "clusterReferencesStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.clusterReferences, "VkDeviceAddress", "clusterReferences", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureBuildTriangleClusterInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureBuildTriangleClusterInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.clusterID, "uint32_t", "clusterID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureClusterFlagsNV(api_dump, object.clusterFlags, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.triangleCount, "uint32_t:9", "triangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexCount, "uint32_t:9", "vertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.positionTruncateBitCount, "uint32_t:6", "positionTruncateBitCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.indexType, "uint32_t:4", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.opacityMicromapIndexType, "uint32_t:4", "opacityMicromapIndexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(api_dump, object.baseGeometryIndexAndGeometryFlags, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.indexBufferStride, "uint16_t", "indexBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.vertexBufferStride, "uint16_t", "vertexBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.geometryIndexAndFlagsBufferStride, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.opacityMicromapIndexBufferStride, "uint16_t", "opacityMicromapIndexBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.indexBuffer, "VkDeviceAddress", "indexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.vertexBuffer, "VkDeviceAddress", "vertexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.geometryIndexAndFlagsBuffer, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.opacityMicromapArray, "VkDeviceAddress", "opacityMicromapArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.opacityMicromapIndexBuffer, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.clusterID, "uint32_t", "clusterID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureClusterFlagsNV(api_dump, object.clusterFlags, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.triangleCount, "uint32_t:9", "triangleCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.vertexCount, "uint32_t:9", "vertexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.positionTruncateBitCount, "uint32_t:6", "positionTruncateBitCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.indexType, "uint32_t:4", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.opacityMicromapIndexType, "uint32_t:4", "opacityMicromapIndexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(api_dump, object.baseGeometryIndexAndGeometryFlags, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.indexBufferStride, "uint16_t", "indexBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.vertexBufferStride, "uint16_t", "vertexBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.geometryIndexAndFlagsBufferStride, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint16_t>(api_dump, object.opacityMicromapIndexBufferStride, "uint16_t", "opacityMicromapIndexBufferStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.indexBuffer, "VkDeviceAddress", "indexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.vertexBuffer, "VkDeviceAddress", "vertexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.geometryIndexAndFlagsBuffer, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.opacityMicromapArray, "VkDeviceAddress", "opacityMicromapArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.opacityMicromapIndexBuffer, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.instantiationBoundingBoxLimit, "VkDeviceAddress", "instantiationBoundingBoxLimit", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureInstantiateClusterInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureInstantiateClusterInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.clusterIdOffset, "uint32_t", "clusterIdOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.geometryIndexOffset, "uint32_t:24", "geometryIndexOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.reserved, "uint32_t:8", "reserved", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.clusterTemplateAddress, "VkDeviceAddress", "clusterTemplateAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressNV(api_dump, object.vertexBuffer, "VkStridedDeviceAddressNV", "vertexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkClusterAccelerationStructureGetTemplateIndicesInfoNV(ApiDumpInstance& api_dump, const VkClusterAccelerationStructureGetTemplateIndicesInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.clusterTemplateAddress, "VkDeviceAddress", "clusterTemplateAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureBuildSizesInfoKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureBuildSizesInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.accelerationStructureSize, "VkDeviceSize", "accelerationStructureSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.updateScratchSize, "VkDeviceSize", "updateScratchSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.buildScratchSize, "VkDeviceSize", "buildScratchSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(ApiDumpInstance& api_dump, const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.allowClusterAccelerationStructure, "VkBool32", "allowClusterAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.partitionedAccelerationStructure, "VkBool32", "partitionedAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPartitionCount, "uint32_t", "maxPartitionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPartitionedAccelerationStructureFlagsNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureFlagsNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.enablePartitionTranslation, "VkBool32", "enablePartitionTranslation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBuildPartitionedAccelerationStructureIndirectCommandNV(ApiDumpInstance& api_dump, const VkBuildPartitionedAccelerationStructureIndirectCommandNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPartitionedAccelerationStructureOpTypeNV(api_dump, object.opType, "VkPartitionedAccelerationStructureOpTypeNV", "opType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.argCount, "uint32_t", "argCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkStridedDeviceAddressNV(api_dump, object.argData, "VkStridedDeviceAddressNV", "argData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPartitionedAccelerationStructureWriteInstanceDataNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureWriteInstanceDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkTransformMatrixKHR(api_dump, object.transform, "VkTransformMatrixKHR", "transform", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.explicitAABB, 6, "float[6]", "explicitAABB", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceID, "uint32_t", "instanceID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceMask, "uint32_t", "instanceMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceContributionToHitGroupIndex, "uint32_t", "instanceContributionToHitGroupIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPartitionedAccelerationStructureInstanceFlagsNV(api_dump, object.instanceFlags, "VkPartitionedAccelerationStructureInstanceFlagsNV", "instanceFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceIndex, "uint32_t", "instanceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.partitionIndex, "uint32_t", "partitionIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.accelerationStructure, "VkDeviceAddress", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPartitionedAccelerationStructureUpdateInstanceDataNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureUpdateInstanceDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.instanceIndex, "uint32_t", "instanceIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceContributionToHitGroupIndex, "uint32_t", "instanceContributionToHitGroupIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.accelerationStructure, "VkDeviceAddress", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPartitionedAccelerationStructureWritePartitionTranslationDataNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureWritePartitionTranslationDataNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.partitionIndex, "uint32_t", "partitionIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.partitionTranslation, 3, "float[3]", "partitionTranslation", "float", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<float>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteDescriptorSetPartitionedAccelerationStructureNV(ApiDumpInstance& api_dump, const VkWriteDescriptorSetPartitionedAccelerationStructureNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.accelerationStructureCount, "uint32_t", "accelerationStructureCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAccelerationStructures, object.accelerationStructureCount, "const VkDeviceAddress*", "pAccelerationStructures", "const VkDeviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const VkDeviceAddress>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPartitionedAccelerationStructureInstancesInputNV(ApiDumpInstance& api_dump, const VkPartitionedAccelerationStructureInstancesInputNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildAccelerationStructureFlagsKHR(api_dump, object.flags, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.instanceCount, "uint32_t", "instanceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInstancePerPartitionCount, "uint32_t", "maxInstancePerPartitionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.partitionCount, "uint32_t", "partitionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxInstanceInGlobalPartitionCount, "uint32_t", "maxInstanceInGlobalPartitionCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBuildPartitionedAccelerationStructureInfoNV(ApiDumpInstance& api_dump, const VkBuildPartitionedAccelerationStructureInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPartitionedAccelerationStructureInstancesInputNV(api_dump, object.input, "VkPartitionedAccelerationStructureInstancesInputNV", "input", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcAccelerationStructureData, "VkDeviceAddress", "srcAccelerationStructureData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.dstAccelerationStructureData, "VkDeviceAddress", "dstAccelerationStructureData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.scratchData, "VkDeviceAddress", "scratchData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcInfos, "VkDeviceAddress", "srcInfos", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.srcInfosCount, "VkDeviceAddress", "srcInfosCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedCommands, "VkBool32", "deviceGeneratedCommands", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dynamicGeneratedPipelineLayout, "VkBool32", "dynamicGeneratedPipelineLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectPipelineCount, "uint32_t", "maxIndirectPipelineCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectShaderObjectCount, "uint32_t", "maxIndirectShaderObjectCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectSequenceCount, "uint32_t", "maxIndirectSequenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsTokenCount, "uint32_t", "maxIndirectCommandsTokenCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsTokenOffset, "uint32_t", "maxIndirectCommandsTokenOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxIndirectCommandsIndirectStride, "uint32_t", "maxIndirectCommandsIndirectStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsInputModeFlagsEXT(api_dump, object.supportedIndirectCommandsInputModes, "VkIndirectCommandsInputModeFlagsEXT", "supportedIndirectCommandsInputModes", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.supportedIndirectCommandsShaderStages, "VkShaderStageFlags", "supportedIndirectCommandsShaderStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.supportedIndirectCommandsShaderStagesPipelineBinding, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesPipelineBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.supportedIndirectCommandsShaderStagesShaderBinding, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesShaderBinding", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedCommandsTransformFeedback, "VkBool32", "deviceGeneratedCommandsTransformFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.deviceGeneratedCommandsMultiDrawIndirectCount, "VkBool32", "deviceGeneratedCommandsMultiDrawIndirectCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeneratedCommandsMemoryRequirementsInfoEXT(ApiDumpInstance& api_dump, const VkGeneratedCommandsMemoryRequirementsInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectExecutionSetEXT(api_dump, object.indirectExecutionSet, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsLayoutEXT(api_dump, object.indirectCommandsLayout, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSequenceCount, "uint32_t", "maxSequenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDrawCount, "uint32_t", "maxDrawCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectExecutionSetPipelineInfoEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetPipelineInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.initialPipeline, "VkPipeline", "initialPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPipelineCount, "uint32_t", "maxPipelineCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectExecutionSetShaderLayoutInfoEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetShaderLayoutInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.setLayoutCount, "uint32_t", "setLayoutCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSetLayouts, object.setLayoutCount, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectExecutionSetShaderInfoEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetShaderInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderCount, "uint32_t", "shaderCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pInitialShaders, object.shaderCount, "const VkShaderEXT*", "pInitialShaders", "const VkShaderEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkShaderEXT);
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pSetLayoutInfos, object.shaderCount, "const VkIndirectExecutionSetShaderLayoutInfoEXT*", "pSetLayoutInfos", "const VkIndirectExecutionSetShaderLayoutInfoEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetShaderLayoutInfoEXT);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxShaderCount, "uint32_t", "maxShaderCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.pushConstantRangeCount, "uint32_t", "pushConstantRangeCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pPushConstantRanges, object.pushConstantRangeCount, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectExecutionSetInfoEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    if (api_dump.getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT) {
+        dump_pointer(api_dump, object.pPipelineInfo, "const VkIndirectExecutionSetPipelineInfoEXT*", "pPipelineInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetPipelineInfoEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT) {
+        dump_pointer(api_dump, object.pShaderInfo, "const VkIndirectExecutionSetShaderInfoEXT*", "pShaderInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetShaderInfoEXT);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectExecutionSetCreateInfoEXT(ApiDumpInstance& api_dump, const VkIndirectExecutionSetCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectExecutionSetInfoTypeEXT(api_dump, object.type, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectExecutionSetInfoEXT(api_dump, object.info, "VkIndirectExecutionSetInfoEXT", "info", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeneratedCommandsInfoEXT(ApiDumpInstance& api_dump, const VkGeneratedCommandsInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.shaderStages, "VkShaderStageFlags", "shaderStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectExecutionSetEXT(api_dump, object.indirectExecutionSet, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsLayoutEXT(api_dump, object.indirectCommandsLayout, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.indirectAddress, "VkDeviceAddress", "indirectAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.indirectAddressSize, "VkDeviceSize", "indirectAddressSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.preprocessAddress, "VkDeviceAddress", "preprocessAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.preprocessSize, "VkDeviceSize", "preprocessSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxSequenceCount, "uint32_t", "maxSequenceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.sequenceCountAddress, "VkDeviceAddress", "sequenceCountAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDrawCount, "uint32_t", "maxDrawCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteIndirectExecutionSetPipelineEXT(ApiDumpInstance& api_dump, const VkWriteIndirectExecutionSetPipelineEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsPushConstantTokenEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsPushConstantTokenEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkPushConstantRange(api_dump, object.updateRange, "VkPushConstantRange", "updateRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsVertexBufferTokenEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsVertexBufferTokenEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.vertexBindingUnit, "uint32_t", "vertexBindingUnit", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsIndexBufferTokenEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsIndexBufferTokenEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkIndirectCommandsInputModeFlagBitsEXT(api_dump, object.mode, "VkIndirectCommandsInputModeFlagBitsEXT", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsExecutionSetTokenEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsExecutionSetTokenEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkIndirectExecutionSetInfoTypeEXT(api_dump, object.type, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.shaderStages, "VkShaderStageFlags", "shaderStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsTokenDataEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsTokenDataEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    if (api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT) {
+        dump_pointer(api_dump, object.pPushConstant, "const VkIndirectCommandsPushConstantTokenEXT*", "pPushConstant", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsPushConstantTokenEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT) {
+        dump_pointer(api_dump, object.pVertexBuffer, "const VkIndirectCommandsVertexBufferTokenEXT*", "pVertexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsVertexBufferTokenEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT) {
+        dump_pointer(api_dump, object.pIndexBuffer, "const VkIndirectCommandsIndexBufferTokenEXT*", "pIndexBuffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsIndexBufferTokenEXT);
+    }
+    dump_separate_members(api_dump);
+    if (api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT) {
+        dump_pointer(api_dump, object.pExecutionSet, "const VkIndirectCommandsExecutionSetTokenEXT*", "pExecutionSet", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsExecutionSetTokenEXT);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsLayoutTokenEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutTokenEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    api_dump.setIndirectCommandsLayoutToken(object.type);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsTokenTypeEXT(api_dump, object.type, "VkIndirectCommandsTokenTypeEXT", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsTokenDataEXT(api_dump, object.data, "VkIndirectCommandsTokenDataEXT", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.offset, "uint32_t", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkIndirectCommandsLayoutCreateInfoEXT(ApiDumpInstance& api_dump, const VkIndirectCommandsLayoutCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndirectCommandsLayoutUsageFlagsEXT(api_dump, object.flags, "VkIndirectCommandsLayoutUsageFlagsEXT", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderStageFlags(api_dump, object.shaderStages, "VkShaderStageFlags", "shaderStages", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.indirectStride, "uint32_t", "indirectStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.pipelineLayout, "VkPipelineLayout", "pipelineLayout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.tokenCount, "uint32_t", "tokenCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pTokens, object.tokenCount, "const VkIndirectCommandsLayoutTokenEXT*", "pTokens", "const VkIndirectCommandsLayoutTokenEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsLayoutTokenEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrawIndirectCountIndirectCommandEXT(ApiDumpInstance& api_dump, const VkDrawIndirectCountIndirectCommandEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.bufferAddress, "VkDeviceAddress", "bufferAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stride, "uint32_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.commandCount, "uint32_t", "commandCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindVertexBufferIndirectCommandEXT(ApiDumpInstance& api_dump, const VkBindVertexBufferIndirectCommandEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.bufferAddress, "VkDeviceAddress", "bufferAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stride, "uint32_t", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBindIndexBufferIndirectCommandEXT(ApiDumpInstance& api_dump, const VkBindIndexBufferIndirectCommandEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.bufferAddress, "VkDeviceAddress", "bufferAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.size, "uint32_t", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeneratedCommandsPipelineInfoEXT(ApiDumpInstance& api_dump, const VkGeneratedCommandsPipelineInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.pipeline, "VkPipeline", "pipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkGeneratedCommandsShaderInfoEXT(ApiDumpInstance& api_dump, const VkGeneratedCommandsShaderInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderCount, "uint32_t", "shaderCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pShaders, object.shaderCount, "const VkShaderEXT*", "pShaders", "const VkShaderEXT", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkShaderEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteIndirectExecutionSetShaderEXT(ApiDumpInstance& api_dump, const VkWriteIndirectExecutionSetShaderEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.index, "uint32_t", "index", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkShaderEXT(api_dump, object.shader, "VkShaderEXT", "shader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageAlignmentControlFeaturesMESA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.imageAlignmentControl, "VkBool32", "imageAlignmentControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(ApiDumpInstance& api_dump, const VkPhysicalDeviceImageAlignmentControlPropertiesMESA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.supportedImageAlignmentMask, "uint32_t", "supportedImageAlignmentMask", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkImageAlignmentControlCreateInfoMESA(ApiDumpInstance& api_dump, const VkImageAlignmentControlCreateInfoMESA& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maximumRequestedAlignment, "uint32_t", "maximumRequestedAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPushConstantBankInfoNV(ApiDumpInstance& api_dump, const VkPushConstantBankInfoNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.bank, "uint32_t", "bank", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePushConstantBankFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePushConstantBankFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pushConstantBank, "VkBool32", "pushConstantBank", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePushConstantBankPropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePushConstantBankPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGraphicsPushConstantBanks, "uint32_t", "maxGraphicsPushConstantBanks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxComputePushConstantBanks, "uint32_t", "maxComputePushConstantBanks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxGraphicsPushDataBanks, "uint32_t", "maxGraphicsPushDataBanks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxComputePushDataBanks, "uint32_t", "maxComputePushDataBanks", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRayTracingInvocationReorderModeEXT(api_dump, object.rayTracingInvocationReorderReorderingHint, "VkRayTracingInvocationReorderModeEXT", "rayTracingInvocationReorderReorderingHint", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxShaderBindingTableRecordIndex, "uint32_t", "maxShaderBindingTableRecordIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingInvocationReorder, "VkBool32", "rayTracingInvocationReorder", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDepthClampControlFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceDepthClampControlFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.depthClampControl, "VkBool32", "depthClampControl", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineViewportDepthClampControlCreateInfoEXT(ApiDumpInstance& api_dump, const VkPipelineViewportDepthClampControlCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDepthClampModeEXT(api_dump, object.depthClampMode, "VkDepthClampModeEXT", "depthClampMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDepthClampRange, "const VkDepthClampRangeEXT*", "pDepthClampRange", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkDepthClampRangeEXT);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkSurfaceCreateInfoOHOS(ApiDumpInstance& api_dump, const VkSurfaceCreateInfoOHOS& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkSurfaceCreateFlagsOHOS(api_dump, object.flags, "VkSurfaceCreateFlagsOHOS", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<OHNativeWindow*>(api_dump, object.window, "OHNativeWindow*", "window", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkPhysicalDeviceHdrVividFeaturesHUAWEI(ApiDumpInstance& api_dump, const VkPhysicalDeviceHdrVividFeaturesHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.hdrVivid, "VkBool32", "hdrVivid", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkHdrVividDynamicMetadataHUAWEI(ApiDumpInstance& api_dump, const VkHdrVividDynamicMetadataHUAWEI& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<size_t>(api_dump, object.dynamicMetadataSize, "size_t", "dynamicMetadataSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pDynamicMetadata, "const void*", "pDynamicMetadata", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance& api_dump, const VkCooperativeMatrixFlexibleDimensionsPropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.MGranularity, "uint32_t", "MGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.NGranularity, "uint32_t", "NGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.KGranularity, "uint32_t", "KGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.AType, "VkComponentTypeKHR", "AType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.BType, "VkComponentTypeKHR", "BType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.CType, "VkComponentTypeKHR", "CType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkComponentTypeKHR(api_dump, object.ResultType, "VkComponentTypeKHR", "ResultType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.saturatingAccumulation, "VkBool32", "saturatingAccumulation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkScopeKHR(api_dump, object.scope, "VkScopeKHR", "scope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.workgroupInvocations, "uint32_t", "workgroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrix2FeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixWorkgroupScope, "VkBool32", "cooperativeMatrixWorkgroupScope", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixFlexibleDimensions, "VkBool32", "cooperativeMatrixFlexibleDimensions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixReductions, "VkBool32", "cooperativeMatrixReductions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixConversions, "VkBool32", "cooperativeMatrixConversions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixPerElementOperations, "VkBool32", "cooperativeMatrixPerElementOperations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixTensorAddressing, "VkBool32", "cooperativeMatrixTensorAddressing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.cooperativeMatrixBlockLoads, "VkBool32", "cooperativeMatrixBlockLoads", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceCooperativeMatrix2PropertiesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize, "uint32_t", "cooperativeMatrixWorkgroupScopeMaxWorkgroupSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cooperativeMatrixFlexibleDimensionsMaxDimension, "uint32_t", "cooperativeMatrixFlexibleDimensionsMaxDimension", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cooperativeMatrixWorkgroupScopeReservedSharedMemory, "uint32_t", "cooperativeMatrixWorkgroupScopeReservedSharedMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineOpacityMicromap, "VkBool32", "pipelineOpacityMicromap", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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);
+void dump_VkImportMemoryMetalHandleInfoEXT(ApiDumpInstance& api_dump, const VkImportMemoryMetalHandleInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<void*>(api_dump, object.handle, "void*", "handle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryMetalHandlePropertiesEXT(ApiDumpInstance& api_dump, const VkMemoryMetalHandlePropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.memoryTypeBits, "uint32_t", "memoryTypeBits", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkMemoryGetMetalHandleInfoEXT(ApiDumpInstance& api_dump, const VkMemoryGetMetalHandleInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceMemory(api_dump, object.memory, "VkDeviceMemory", "memory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExternalMemoryHandleTypeFlagBits(api_dump, object.handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, 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<Format>(object.pCounterAddresses, settings, "const VkDeviceAddress*", "pCounterAddresses", 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<Format>(object.pCounterIndices, settings, "uint32_t*", "pCounterIndices", 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_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);
+void dump_VkPhysicalDevicePerformanceCountersByRegionFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.performanceCountersByRegion, "VkBool32", "performanceCountersByRegion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePerformanceCountersByRegionPropertiesARM(ApiDumpInstance& api_dump, const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerRegionPerformanceCounters, "uint32_t", "maxPerRegionPerformanceCounters", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkExtent2D(api_dump, object.performanceCounterRegionSize, "VkExtent2D", "performanceCounterRegionSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.rowStrideAlignment, "uint32_t", "rowStrideAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.regionAlignment, "uint32_t", "regionAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.identityTransformOrder, "VkBool32", "identityTransformOrder", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceCounterARM(ApiDumpInstance& api_dump, const VkPerformanceCounterARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.counterID, "uint32_t", "counterID", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPerformanceCounterDescriptionARM(ApiDumpInstance& api_dump, const VkPerformanceCounterDescriptionARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPerformanceCounterDescriptionFlagsARM(api_dump, object.flags, "VkPerformanceCounterDescriptionFlagsARM", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_char(api_dump, object.name, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRenderPassPerformanceCountersByRegionBeginInfoARM(ApiDumpInstance& api_dump, const VkRenderPassPerformanceCountersByRegionBeginInfoARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.counterAddressCount, "uint32_t", "counterAddressCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCounterAddresses, "const VkDeviceAddress*", "pCounterAddresses", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const VkDeviceAddress>);
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.serializeRegions, "VkBool32", "serializeRegions", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.counterIndexCount, "uint32_t", "counterIndexCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pCounterIndices, "uint32_t*", "pCounterIndices", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.vertexAttributeRobustness, "VkBool32", "vertexAttributeRobustness", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFormatPackFeaturesARM(ApiDumpInstance& api_dump, const VkPhysicalDeviceFormatPackFeaturesARM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.formatPack, "VkBool32", "formatPack", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.fragmentDensityMapLayered, "VkBool32", "fragmentDensityMapLayered", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE(ApiDumpInstance& api_dump, const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentDensityMapLayers, "uint32_t", "maxFragmentDensityMapLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineFragmentDensityMapLayeredCreateInfoVALVE(ApiDumpInstance& api_dump, const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxFragmentDensityMapLayers, "uint32_t", "maxFragmentDensityMapLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
 }
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
-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);
+void dump_VkSetPresentConfigNV(ApiDumpInstance& api_dump, const VkSetPresentConfigNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.numFramesPerBatch, "uint32_t", "numFramesPerBatch", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.presentConfigFeedback, "uint32_t", "presentConfigFeedback", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePresentMeteringFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDevicePresentMeteringFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.presentMetering, "VkBool32", "presentMetering", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
-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_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);
-}
-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);
+void dump_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.zeroInitializeDeviceMemory, "VkBool32", "zeroInitializeDeviceMemory", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShader64BitIndexingFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShader64BitIndexingFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shader64BitIndexing, "VkBool32", "shader64BitIndexing", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceCustomResolveFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceCustomResolveFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.customResolve, "VkBool32", "customResolve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkBeginCustomResolveInfoEXT(ApiDumpInstance& api_dump, const VkBeginCustomResolveInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCustomResolveCreateInfoEXT(ApiDumpInstance& api_dump, const VkCustomResolveCreateInfoEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.customResolve, "VkBool32", "customResolve", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.colorAttachmentCount, "uint32_t", "colorAttachmentCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pColorAttachmentFormats, object.colorAttachmentCount, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat);
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.depthAttachmentFormat, "VkFormat", "depthAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.stencilAttachmentFormat, "VkFormat", "stencilAttachmentFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPipelineCacheHeaderVersionDataGraphQCOM(ApiDumpInstance& api_dump, const VkPipelineCacheHeaderVersionDataGraphQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.headerSize, "uint32_t", "headerSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCacheHeaderVersion(api_dump, object.headerVersion, "VkPipelineCacheHeaderVersion", "headerVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDataGraphModelCacheTypeQCOM(api_dump, object.cacheType, "VkDataGraphModelCacheTypeQCOM", "cacheType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.cacheVersion, "uint32_t", "cacheVersion", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.toolchainVersion, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM, "uint32_t[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM]", "toolchainVersion", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDataGraphPipelineBuiltinModelCreateInfoQCOM(ApiDumpInstance& api_dump, const VkDataGraphPipelineBuiltinModelCreateInfoQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pOperation, "const VkPhysicalDeviceDataGraphOperationSupportARM*", "pOperation", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceDataGraphOperationSupportARM);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceDataGraphModelFeaturesQCOM(ApiDumpInstance& api_dump, const VkPhysicalDeviceDataGraphModelFeaturesQCOM& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.dataGraphModel, "VkBool32", "dataGraphModel", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderLongVectorFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderLongVectorFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.longVector, "VkBool32", "longVector", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderLongVectorPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderLongVectorPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVectorComponents, "uint32_t", "maxVectorComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(ApiDumpInstance& api_dump, const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.pipelineCacheIncrementalMode, "VkBool32", "pipelineCacheIncrementalMode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderUniformBufferUnsizedArray, "VkBool32", "shaderUniformBufferUnsizedArray", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkComputeOccupancyPriorityParametersNV(ApiDumpInstance& api_dump, const VkComputeOccupancyPriorityParametersNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.occupancyPriority, "float", "occupancyPriority", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<float>(api_dump, object.occupancyThrottling, "float", "occupancyThrottling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV(ApiDumpInstance& api_dump, const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.computeOccupancyPriority, "VkBool32", "computeOccupancyPriority", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.shaderSubgroupPartitioned, "VkBool32", "shaderSubgroupPartitioned", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureBuildRangeInfoKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureBuildRangeInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.primitiveCount, "uint32_t", "primitiveCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.primitiveOffset, "uint32_t", "primitiveOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.firstVertex, "uint32_t", "firstVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.transformOffset, "uint32_t", "transformOffset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryTrianglesDataKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryTrianglesDataKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkFormat(api_dump, object.vertexFormat, "VkFormat", "vertexFormat", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.vertexData, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.vertexStride, "VkDeviceSize", "vertexStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxVertex, "uint32_t", "maxVertex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkIndexType(api_dump, object.indexType, "VkIndexType", "indexType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.indexData, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.transformData, "VkDeviceOrHostAddressConstKHR", "transformData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryAabbsDataKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryAabbsDataKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.data, "VkDeviceOrHostAddressConstKHR", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.stride, "VkDeviceSize", "stride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryInstancesDataKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryInstancesDataKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.arrayOfPointers, "VkBool32", "arrayOfPointers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.data, "VkDeviceOrHostAddressConstKHR", "data", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryDataKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryDataKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_union, type_name, var_name, indents, address);
+    dump_VkAccelerationStructureGeometryTrianglesDataKHR(api_dump, object.triangles, "VkAccelerationStructureGeometryTrianglesDataKHR", "triangles", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureGeometryAabbsDataKHR(api_dump, object.aabbs, "VkAccelerationStructureGeometryAabbsDataKHR", "aabbs", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureGeometryInstancesDataKHR(api_dump, object.instances, "VkAccelerationStructureGeometryInstancesDataKHR", "instances", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureGeometryKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureGeometryKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryTypeKHR(api_dump, object.geometryType, "VkGeometryTypeKHR", "geometryType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureGeometryDataKHR(api_dump, object.geometry, "VkAccelerationStructureGeometryDataKHR", "geometry", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkGeometryFlagsKHR(api_dump, object.flags, "VkGeometryFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureBuildGeometryInfoKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureBuildGeometryInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureTypeKHR(api_dump, object.type, "VkAccelerationStructureTypeKHR", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildAccelerationStructureFlagsKHR(api_dump, object.flags, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuildAccelerationStructureModeKHR(api_dump, object.mode, "VkBuildAccelerationStructureModeKHR", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.srcAccelerationStructure, "VkAccelerationStructureKHR", "srcAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.dstAccelerationStructure, "VkAccelerationStructureKHR", "dstAccelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.geometryCount, "uint32_t", "geometryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pGeometries, object.geometryCount, "const VkAccelerationStructureGeometryKHR*", "pGeometries", "const VkAccelerationStructureGeometryKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureGeometryKHR);
+    dump_separate_members(api_dump);
+    dump_double_pointer_array(api_dump, object.ppGeometries, object.geometryCount * 1, "const VkAccelerationStructureGeometryKHR* const*", "ppGeometries", "const VkAccelerationStructureGeometryKHR*", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureGeometryKHR);
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressKHR(api_dump, object.scratchData, "VkDeviceOrHostAddressKHR", "scratchData", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureCreateInfoKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureCreateFlagsKHR(api_dump, object.createFlags, "VkAccelerationStructureCreateFlagsKHR", "createFlags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkBuffer(api_dump, object.buffer, "VkBuffer", "buffer", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.offset, "VkDeviceSize", "offset", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkDeviceSize>(api_dump, object.size, "VkDeviceSize", "size", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureTypeKHR(api_dump, object.type, "VkAccelerationStructureTypeKHR", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type_hex<VkDeviceAddress>(api_dump, object.deviceAddress, "VkDeviceAddress", "deviceAddress", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkWriteDescriptorSetAccelerationStructureKHR(ApiDumpInstance& api_dump, const VkWriteDescriptorSetAccelerationStructureKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.accelerationStructureCount, "uint32_t", "accelerationStructureCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pAccelerationStructures, object.accelerationStructureCount, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureKHR);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceAccelerationStructureFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceAccelerationStructureFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.accelerationStructure, "VkBool32", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.accelerationStructureCaptureReplay, "VkBool32", "accelerationStructureCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.accelerationStructureIndirectBuild, "VkBool32", "accelerationStructureIndirectBuild", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.accelerationStructureHostCommands, "VkBool32", "accelerationStructureHostCommands", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.descriptorBindingAccelerationStructureUpdateAfterBind, "VkBool32", "descriptorBindingAccelerationStructureUpdateAfterBind", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceAccelerationStructurePropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceAccelerationStructurePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxGeometryCount, "uint64_t", "maxGeometryCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxInstanceCount, "uint64_t", "maxInstanceCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint64_t>(api_dump, object.maxPrimitiveCount, "uint64_t", "maxPrimitiveCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorAccelerationStructures, "uint32_t", "maxPerStageDescriptorAccelerationStructures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPerStageDescriptorUpdateAfterBindAccelerationStructures, "uint32_t", "maxPerStageDescriptorUpdateAfterBindAccelerationStructures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetAccelerationStructures, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxDescriptorSetUpdateAfterBindAccelerationStructures, "uint32_t", "maxDescriptorSetUpdateAfterBindAccelerationStructures", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.minAccelerationStructureScratchOffsetAlignment, "uint32_t", "minAccelerationStructureScratchOffsetAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureDeviceAddressInfoKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureDeviceAddressInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.accelerationStructure, "VkAccelerationStructureKHR", "accelerationStructure", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkAccelerationStructureVersionInfoKHR(ApiDumpInstance& api_dump, const VkAccelerationStructureVersionInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pVersionData, 2 * VK_UUID_SIZE, "const uint8_t*", "pVersionData", "const uint8_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<const uint8_t>);
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyAccelerationStructureToMemoryInfoKHR(ApiDumpInstance& api_dump, const VkCopyAccelerationStructureToMemoryInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.src, "VkAccelerationStructureKHR", "src", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressKHR(api_dump, object.dst, "VkDeviceOrHostAddressKHR", "dst", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCopyAccelerationStructureModeKHR(api_dump, object.mode, "VkCopyAccelerationStructureModeKHR", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyMemoryToAccelerationStructureInfoKHR(ApiDumpInstance& api_dump, const VkCopyMemoryToAccelerationStructureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkDeviceOrHostAddressConstKHR(api_dump, object.src, "VkDeviceOrHostAddressConstKHR", "src", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.dst, "VkAccelerationStructureKHR", "dst", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCopyAccelerationStructureModeKHR(api_dump, object.mode, "VkCopyAccelerationStructureModeKHR", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkCopyAccelerationStructureInfoKHR(ApiDumpInstance& api_dump, const VkCopyAccelerationStructureInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.src, "VkAccelerationStructureKHR", "src", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkAccelerationStructureKHR(api_dump, object.dst, "VkAccelerationStructureKHR", "dst", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkCopyAccelerationStructureModeKHR(api_dump, object.mode, "VkCopyAccelerationStructureModeKHR", "mode", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRayTracingShaderGroupCreateInfoKHR(ApiDumpInstance& api_dump, const VkRayTracingShaderGroupCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkRayTracingShaderGroupTypeKHR(api_dump, object.type, "VkRayTracingShaderGroupTypeKHR", "type", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.generalShader, "uint32_t", "generalShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.closestHitShader, "uint32_t", "closestHitShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.anyHitShader, "uint32_t", "anyHitShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.intersectionShader, "uint32_t", "intersectionShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<const void*>(api_dump, object.pShaderGroupCaptureReplayHandle, "const void*", "pShaderGroupCaptureReplayHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRayTracingPipelineInterfaceCreateInfoKHR(ApiDumpInstance& api_dump, const VkRayTracingPipelineInterfaceCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPipelineRayPayloadSize, "uint32_t", "maxPipelineRayPayloadSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPipelineRayHitAttributeSize, "uint32_t", "maxPipelineRayHitAttributeSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkRayTracingPipelineCreateInfoKHR(ApiDumpInstance& api_dump, const VkRayTracingPipelineCreateInfoKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "const void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipelineCreateFlags(api_dump, object.flags, "VkPipelineCreateFlags", "flags", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.stageCount, "uint32_t", "stageCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pStages, object.stageCount, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.groupCount, "uint32_t", "groupCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer_array(api_dump, object.pGroups, object.groupCount, "const VkRayTracingShaderGroupCreateInfoKHR*", "pGroups", "const VkRayTracingShaderGroupCreateInfoKHR", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingShaderGroupCreateInfoKHR);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPipelineRayRecursionDepth, "uint32_t", "maxPipelineRayRecursionDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLibraryInfo, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineLibraryCreateInfoKHR);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pLibraryInterface, "const VkRayTracingPipelineInterfaceCreateInfoKHR*", "pLibraryInterface", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingPipelineInterfaceCreateInfoKHR);
+    dump_separate_members(api_dump);
+    dump_pointer(api_dump, object.pDynamicState, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDynamicStateCreateInfo);
+    dump_separate_members(api_dump);
+    dump_VkPipelineLayout(api_dump, object.layout, "VkPipelineLayout", "layout", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_VkPipeline(api_dump, object.basePipelineHandle, "VkPipeline", "basePipelineHandle", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<int32_t>(api_dump, object.basePipelineIndex, "int32_t", "basePipelineIndex", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "const void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingPipeline, "VkBool32", "rayTracingPipeline", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingPipelineShaderGroupHandleCaptureReplay, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplay", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingPipelineShaderGroupHandleCaptureReplayMixed, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplayMixed", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTracingPipelineTraceRaysIndirect, "VkBool32", "rayTracingPipelineTraceRaysIndirect", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayTraversalPrimitiveCulling, "VkBool32", "rayTraversalPrimitiveCulling", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderGroupHandleSize, "uint32_t", "shaderGroupHandleSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRayRecursionDepth, "uint32_t", "maxRayRecursionDepth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxShaderGroupStride, "uint32_t", "maxShaderGroupStride", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderGroupBaseAlignment, "uint32_t", "shaderGroupBaseAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderGroupHandleCaptureReplaySize, "uint32_t", "shaderGroupHandleCaptureReplaySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRayDispatchInvocationCount, "uint32_t", "maxRayDispatchInvocationCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.shaderGroupHandleAlignment, "uint32_t", "shaderGroupHandleAlignment", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxRayHitAttributeSize, "uint32_t", "maxRayHitAttributeSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkTraceRaysIndirectCommandKHR(ApiDumpInstance& api_dump, const VkTraceRaysIndirectCommandKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.width, "uint32_t", "width", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.height, "uint32_t", "height", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.depth, "uint32_t", "depth", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceRayQueryFeaturesKHR(ApiDumpInstance& api_dump, const VkPhysicalDeviceRayQueryFeaturesKHR& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.rayQuery, "VkBool32", "rayQuery", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMeshShaderFeaturesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMeshShaderFeaturesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.taskShader, "VkBool32", "taskShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.meshShader, "VkBool32", "meshShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.multiviewMeshShader, "VkBool32", "multiviewMeshShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.primitiveFragmentShadingRateMeshShader, "VkBool32", "primitiveFragmentShadingRateMeshShader", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.meshShaderQueries, "VkBool32", "meshShaderQueries", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkPhysicalDeviceMeshShaderPropertiesEXT(ApiDumpInstance& api_dump, const VkPhysicalDeviceMeshShaderPropertiesEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_VkStructureType(api_dump, object.sType, "VkStructureType", "sType", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_pNext(api_dump, object.pNext, "void*", "pNext", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskWorkGroupTotalCount, "uint32_t", "maxTaskWorkGroupTotalCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxTaskWorkGroupCount, 3, "uint32_t[3]", "maxTaskWorkGroupCount", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskWorkGroupInvocations, "uint32_t", "maxTaskWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxTaskWorkGroupSize, 3, "uint32_t[3]", "maxTaskWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskPayloadSize, "uint32_t", "maxTaskPayloadSize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskSharedMemorySize, "uint32_t", "maxTaskSharedMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxTaskPayloadAndSharedMemorySize, "uint32_t", "maxTaskPayloadAndSharedMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshWorkGroupTotalCount, "uint32_t", "maxMeshWorkGroupTotalCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxMeshWorkGroupCount, 3, "uint32_t[3]", "maxMeshWorkGroupCount", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshWorkGroupInvocations, "uint32_t", "maxMeshWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_single_array(api_dump, object.maxMeshWorkGroupSize, 3, "uint32_t[3]", "maxMeshWorkGroupSize", "uint32_t", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1), dump_type<uint32_t>);
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshSharedMemorySize, "uint32_t", "maxMeshSharedMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshPayloadAndSharedMemorySize, "uint32_t", "maxMeshPayloadAndSharedMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputMemorySize, "uint32_t", "maxMeshOutputMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshPayloadAndOutputMemorySize, "uint32_t", "maxMeshPayloadAndOutputMemorySize", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputComponents, "uint32_t", "maxMeshOutputComponents", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputVertices, "uint32_t", "maxMeshOutputVertices", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputPrimitives, "uint32_t", "maxMeshOutputPrimitives", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshOutputLayers, "uint32_t", "maxMeshOutputLayers", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxMeshMultiviewViewCount, "uint32_t", "maxMeshMultiviewViewCount", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.meshOutputPerVertexGranularity, "uint32_t", "meshOutputPerVertexGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.meshOutputPerPrimitiveGranularity, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPreferredTaskWorkGroupInvocations, "uint32_t", "maxPreferredTaskWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.maxPreferredMeshWorkGroupInvocations, "uint32_t", "maxPreferredMeshWorkGroupInvocations", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersLocalInvocationVertexOutput, "VkBool32", "prefersLocalInvocationVertexOutput", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersLocalInvocationPrimitiveOutput, "VkBool32", "prefersLocalInvocationPrimitiveOutput", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersCompactVertexOutput, "VkBool32", "prefersCompactVertexOutput", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<VkBool32>(api_dump, object.prefersCompactPrimitiveOutput, "VkBool32", "prefersCompactPrimitiveOutput", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    if (api_dump.settings().format() == ApiDumpFormat::Text) {
+        dump_pNext_trampoline(api_dump, object.pNext, "void*", "void", indents < 2 ? indents + 1 : indents);
+    }
+    dump_end(api_dump, OutputConstruct::api_struct, indents);
+}
+void dump_VkDrawMeshTasksIndirectCommandEXT(ApiDumpInstance& api_dump, const VkDrawMeshTasksIndirectCommandEXT& object, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
+    dump_start(api_dump, OutputConstruct::api_struct, type_name, var_name, indents, address);
+    dump_type<uint32_t>(api_dump, object.groupCountX, "uint32_t", "groupCountX", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.groupCountY, "uint32_t", "groupCountY", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_separate_members(api_dump);
+    dump_type<uint32_t>(api_dump, object.groupCountZ, "uint32_t", "groupCountZ", indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1));
+    dump_end(api_dump, 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) {
+void dump_pNext_struct_name(ApiDumpInstance& api_dump, const void* object, const char* type_name, const char* var_name, int indents) {
     if (object == nullptr) {
-        dump_nullptr<Format>(settings, type_name, var_name, indents);
+        dump_nullptr(api_dump, 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);
+            dump_pNext_struct_name(api_dump, base_struct.pNext, type_name, var_name, indents);
         } else {
-            dump_nullptr<Format>(settings, "const void*", "pNext", indents);
+            dump_nullptr(api_dump, "const void*", "pNext", indents);
         }
         return;
     }
-    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents);
+    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents);
     switch (base_struct.sType) {
         case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
-            dump_string<Format>(settings, "VkBufferMemoryBarrier");
+            dump_value(api_dump, "VkBufferMemoryBarrier");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
-            dump_string<Format>(settings, "VkImageMemoryBarrier");
+            dump_value(api_dump, "VkImageMemoryBarrier");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
-            dump_string<Format>(settings, "VkMemoryBarrier");
+            dump_value(api_dump, "VkMemoryBarrier");
             break;
 
         case VK_STRUCTURE_TYPE_APPLICATION_INFO:
-            dump_string<Format>(settings, "VkApplicationInfo");
+            dump_value(api_dump, "VkApplicationInfo");
             break;
 
         case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
-            dump_string<Format>(settings, "VkInstanceCreateInfo");
+            dump_value(api_dump, "VkInstanceCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
-            dump_string<Format>(settings, "VkDeviceQueueCreateInfo");
+            dump_value(api_dump, "VkDeviceQueueCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
-            dump_string<Format>(settings, "VkDeviceCreateInfo");
+            dump_value(api_dump, "VkDeviceCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SUBMIT_INFO:
-            dump_string<Format>(settings, "VkSubmitInfo");
+            dump_value(api_dump, "VkSubmitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
-            dump_string<Format>(settings, "VkMappedMemoryRange");
+            dump_value(api_dump, "VkMappedMemoryRange");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkMemoryAllocateInfo");
+            dump_value(api_dump, "VkMemoryAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
-            dump_string<Format>(settings, "VkBindSparseInfo");
+            dump_value(api_dump, "VkBindSparseInfo");
             break;
 
         case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
-            dump_string<Format>(settings, "VkFenceCreateInfo");
+            dump_value(api_dump, "VkFenceCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
-            dump_string<Format>(settings, "VkSemaphoreCreateInfo");
+            dump_value(api_dump, "VkSemaphoreCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
-            dump_string<Format>(settings, "VkQueryPoolCreateInfo");
+            dump_value(api_dump, "VkQueryPoolCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
-            dump_string<Format>(settings, "VkBufferCreateInfo");
+            dump_value(api_dump, "VkBufferCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
-            dump_string<Format>(settings, "VkImageCreateInfo");
+            dump_value(api_dump, "VkImageCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
-            dump_string<Format>(settings, "VkImageViewCreateInfo");
+            dump_value(api_dump, "VkImageViewCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
-            dump_string<Format>(settings, "VkCommandPoolCreateInfo");
+            dump_value(api_dump, "VkCommandPoolCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkCommandBufferAllocateInfo");
+            dump_value(api_dump, "VkCommandBufferAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
-            dump_string<Format>(settings, "VkCommandBufferInheritanceInfo");
+            dump_value(api_dump, "VkCommandBufferInheritanceInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
-            dump_string<Format>(settings, "VkCommandBufferBeginInfo");
+            dump_value(api_dump, "VkCommandBufferBeginInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
-            dump_string<Format>(settings, "VkEventCreateInfo");
+            dump_value(api_dump, "VkEventCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
-            dump_string<Format>(settings, "VkBufferViewCreateInfo");
+            dump_value(api_dump, "VkBufferViewCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
-            dump_string<Format>(settings, "VkShaderModuleCreateInfo");
+            dump_value(api_dump, "VkShaderModuleCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineCacheCreateInfo");
+            dump_value(api_dump, "VkPipelineCacheCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineShaderStageCreateInfo");
+            dump_value(api_dump, "VkPipelineShaderStageCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-            dump_string<Format>(settings, "VkComputePipelineCreateInfo");
+            dump_value(api_dump, "VkComputePipelineCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineLayoutCreateInfo");
+            dump_value(api_dump, "VkPipelineLayoutCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
-            dump_string<Format>(settings, "VkSamplerCreateInfo");
+            dump_value(api_dump, "VkSamplerCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
-            dump_string<Format>(settings, "VkCopyDescriptorSet");
+            dump_value(api_dump, "VkCopyDescriptorSet");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorPoolCreateInfo");
+            dump_value(api_dump, "VkDescriptorPoolCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorSetAllocateInfo");
+            dump_value(api_dump, "VkDescriptorSetAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorSetLayoutCreateInfo");
+            dump_value(api_dump, "VkDescriptorSetLayoutCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
-            dump_string<Format>(settings, "VkWriteDescriptorSet");
+            dump_value(api_dump, "VkWriteDescriptorSet");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineVertexInputStateCreateInfo");
+            dump_value(api_dump, "VkPipelineVertexInputStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineInputAssemblyStateCreateInfo");
+            dump_value(api_dump, "VkPipelineInputAssemblyStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineTessellationStateCreateInfo");
+            dump_value(api_dump, "VkPipelineTessellationStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineViewportStateCreateInfo");
+            dump_value(api_dump, "VkPipelineViewportStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineRasterizationStateCreateInfo");
+            dump_value(api_dump, "VkPipelineRasterizationStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineMultisampleStateCreateInfo");
+            dump_value(api_dump, "VkPipelineMultisampleStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineDepthStencilStateCreateInfo");
+            dump_value(api_dump, "VkPipelineDepthStencilStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineColorBlendStateCreateInfo");
+            dump_value(api_dump, "VkPipelineColorBlendStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineDynamicStateCreateInfo");
+            dump_value(api_dump, "VkPipelineDynamicStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-            dump_string<Format>(settings, "VkGraphicsPipelineCreateInfo");
+            dump_value(api_dump, "VkGraphicsPipelineCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
-            dump_string<Format>(settings, "VkFramebufferCreateInfo");
+            dump_value(api_dump, "VkFramebufferCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
-            dump_string<Format>(settings, "VkRenderPassCreateInfo");
+            dump_value(api_dump, "VkRenderPassCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
-            dump_string<Format>(settings, "VkRenderPassBeginInfo");
+            dump_value(api_dump, "VkRenderPassBeginInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
-            dump_string<Format>(settings, "VkBindBufferMemoryInfo");
+            dump_value(api_dump, "VkBindBufferMemoryInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
-            dump_string<Format>(settings, "VkBindImageMemoryInfo");
+            dump_value(api_dump, "VkBindImageMemoryInfo");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-            dump_string<Format>(settings, "VkMemoryDedicatedRequirements");
+            dump_value(api_dump, "VkMemoryDedicatedRequirements");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkMemoryDedicatedAllocateInfo");
+            dump_value(api_dump, "VkMemoryDedicatedAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
-            dump_string<Format>(settings, "VkMemoryAllocateFlagsInfo");
+            dump_value(api_dump, "VkMemoryAllocateFlagsInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
-            dump_string<Format>(settings, "VkDeviceGroupCommandBufferBeginInfo");
+            dump_value(api_dump, "VkDeviceGroupCommandBufferBeginInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
-            dump_string<Format>(settings, "VkDeviceGroupSubmitInfo");
+            dump_value(api_dump, "VkDeviceGroupSubmitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
-            dump_string<Format>(settings, "VkDeviceGroupBindSparseInfo");
+            dump_value(api_dump, "VkDeviceGroupBindSparseInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
-            dump_string<Format>(settings, "VkBindBufferMemoryDeviceGroupInfo");
+            dump_value(api_dump, "VkBindBufferMemoryDeviceGroupInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
-            dump_string<Format>(settings, "VkBindImageMemoryDeviceGroupInfo");
+            dump_value(api_dump, "VkBindImageMemoryDeviceGroupInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceGroupProperties");
+            dump_value(api_dump, "VkPhysicalDeviceGroupProperties");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
-            dump_string<Format>(settings, "VkDeviceGroupDeviceCreateInfo");
+            dump_value(api_dump, "VkDeviceGroupDeviceCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
-            dump_string<Format>(settings, "VkBufferMemoryRequirementsInfo2");
+            dump_value(api_dump, "VkBufferMemoryRequirementsInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
-            dump_string<Format>(settings, "VkImageMemoryRequirementsInfo2");
+            dump_value(api_dump, "VkImageMemoryRequirementsInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
-            dump_string<Format>(settings, "VkImageSparseMemoryRequirementsInfo2");
+            dump_value(api_dump, "VkImageSparseMemoryRequirementsInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
-            dump_string<Format>(settings, "VkMemoryRequirements2");
+            dump_value(api_dump, "VkMemoryRequirements2");
             break;
 
         case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
-            dump_string<Format>(settings, "VkSparseImageMemoryRequirements2");
+            dump_value(api_dump, "VkSparseImageMemoryRequirements2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
-            dump_string<Format>(settings, "VkPhysicalDeviceFeatures2");
+            dump_value(api_dump, "VkPhysicalDeviceFeatures2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
-            dump_string<Format>(settings, "VkPhysicalDeviceProperties2");
+            dump_value(api_dump, "VkPhysicalDeviceProperties2");
             break;
 
         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
-            dump_string<Format>(settings, "VkFormatProperties2");
+            dump_value(api_dump, "VkFormatProperties2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
-            dump_string<Format>(settings, "VkImageFormatProperties2");
+            dump_value(api_dump, "VkImageFormatProperties2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageFormatInfo2");
+            dump_value(api_dump, "VkPhysicalDeviceImageFormatInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
-            dump_string<Format>(settings, "VkQueueFamilyProperties2");
+            dump_value(api_dump, "VkQueueFamilyProperties2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
-            dump_string<Format>(settings, "VkPhysicalDeviceMemoryProperties2");
+            dump_value(api_dump, "VkPhysicalDeviceMemoryProperties2");
             break;
 
         case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
-            dump_string<Format>(settings, "VkSparseImageFormatProperties2");
+            dump_value(api_dump, "VkSparseImageFormatProperties2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
-            dump_string<Format>(settings, "VkPhysicalDeviceSparseImageFormatInfo2");
+            dump_value(api_dump, "VkPhysicalDeviceSparseImageFormatInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
-            dump_string<Format>(settings, "VkImageViewUsageCreateInfo");
+            dump_value(api_dump, "VkImageViewUsageCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceProtectedMemoryFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceProtectedMemoryFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceProtectedMemoryProperties");
+            dump_value(api_dump, "VkPhysicalDeviceProtectedMemoryProperties");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
-            dump_string<Format>(settings, "VkDeviceQueueInfo2");
+            dump_value(api_dump, "VkDeviceQueueInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
-            dump_string<Format>(settings, "VkProtectedSubmitInfo");
+            dump_value(api_dump, "VkProtectedSubmitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
-            dump_string<Format>(settings, "VkBindImagePlaneMemoryInfo");
+            dump_value(api_dump, "VkBindImagePlaneMemoryInfo");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
-            dump_string<Format>(settings, "VkImagePlaneMemoryRequirementsInfo");
+            dump_value(api_dump, "VkImagePlaneMemoryRequirementsInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalImageFormatInfo");
+            dump_value(api_dump, "VkPhysicalDeviceExternalImageFormatInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-            dump_string<Format>(settings, "VkExternalImageFormatProperties");
+            dump_value(api_dump, "VkExternalImageFormatProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalBufferInfo");
+            dump_value(api_dump, "VkPhysicalDeviceExternalBufferInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
-            dump_string<Format>(settings, "VkExternalBufferProperties");
+            dump_value(api_dump, "VkExternalBufferProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceIDProperties");
+            dump_value(api_dump, "VkPhysicalDeviceIDProperties");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
-            dump_string<Format>(settings, "VkExternalMemoryImageCreateInfo");
+            dump_value(api_dump, "VkExternalMemoryImageCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
-            dump_string<Format>(settings, "VkExternalMemoryBufferCreateInfo");
+            dump_value(api_dump, "VkExternalMemoryBufferCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkExportMemoryAllocateInfo");
+            dump_value(api_dump, "VkExportMemoryAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalFenceInfo");
+            dump_value(api_dump, "VkPhysicalDeviceExternalFenceInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
-            dump_string<Format>(settings, "VkExternalFenceProperties");
+            dump_value(api_dump, "VkExternalFenceProperties");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
-            dump_string<Format>(settings, "VkExportFenceCreateInfo");
+            dump_value(api_dump, "VkExportFenceCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
-            dump_string<Format>(settings, "VkExportSemaphoreCreateInfo");
+            dump_value(api_dump, "VkExportSemaphoreCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalSemaphoreInfo");
+            dump_value(api_dump, "VkPhysicalDeviceExternalSemaphoreInfo");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
-            dump_string<Format>(settings, "VkExternalSemaphoreProperties");
+            dump_value(api_dump, "VkExternalSemaphoreProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSubgroupProperties");
+            dump_value(api_dump, "VkPhysicalDeviceSubgroupProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDevice16BitStorageFeatures");
+            dump_value(api_dump, "VkPhysicalDevice16BitStorageFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVariablePointersFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceVariablePointersFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorUpdateTemplateCreateInfo");
+            dump_value(api_dump, "VkDescriptorUpdateTemplateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance3Properties");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance3Properties");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
-            dump_string<Format>(settings, "VkDescriptorSetLayoutSupport");
+            dump_value(api_dump, "VkDescriptorSetLayoutSupport");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
-            dump_string<Format>(settings, "VkSamplerYcbcrConversionCreateInfo");
+            dump_value(api_dump, "VkSamplerYcbcrConversionCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-            dump_string<Format>(settings, "VkSamplerYcbcrConversionInfo");
+            dump_value(api_dump, "VkSamplerYcbcrConversionInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSamplerYcbcrConversionFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceSamplerYcbcrConversionFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-            dump_string<Format>(settings, "VkSamplerYcbcrConversionImageFormatProperties");
+            dump_value(api_dump, "VkSamplerYcbcrConversionImageFormatProperties");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
-            dump_string<Format>(settings, "VkDeviceGroupRenderPassBeginInfo");
+            dump_value(api_dump, "VkDeviceGroupRenderPassBeginInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDevicePointClippingProperties");
+            dump_value(api_dump, "VkPhysicalDevicePointClippingProperties");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
-            dump_string<Format>(settings, "VkRenderPassInputAttachmentAspectCreateInfo");
+            dump_value(api_dump, "VkRenderPassInputAttachmentAspectCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineTessellationDomainOriginStateCreateInfo");
+            dump_value(api_dump, "VkPipelineTessellationDomainOriginStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
-            dump_string<Format>(settings, "VkRenderPassMultiviewCreateInfo");
+            dump_value(api_dump, "VkRenderPassMultiviewCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceMultiviewFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewProperties");
+            dump_value(api_dump, "VkPhysicalDeviceMultiviewProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderDrawParametersFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderDrawParametersFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan11Features");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan11Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan11Properties");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan11Properties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan12Features");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan12Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan12Properties");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan12Properties");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
-            dump_string<Format>(settings, "VkImageFormatListCreateInfo");
+            dump_value(api_dump, "VkImageFormatListCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceDriverProperties");
+            dump_value(api_dump, "VkPhysicalDeviceDriverProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkanMemoryModelFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceVulkanMemoryModelFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceHostQueryResetFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceHostQueryResetFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceTimelineSemaphoreFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceTimelineSemaphoreFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceTimelineSemaphoreProperties");
+            dump_value(api_dump, "VkPhysicalDeviceTimelineSemaphoreProperties");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
-            dump_string<Format>(settings, "VkSemaphoreTypeCreateInfo");
+            dump_value(api_dump, "VkSemaphoreTypeCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-            dump_string<Format>(settings, "VkTimelineSemaphoreSubmitInfo");
+            dump_value(api_dump, "VkTimelineSemaphoreSubmitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
-            dump_string<Format>(settings, "VkSemaphoreWaitInfo");
+            dump_value(api_dump, "VkSemaphoreWaitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
-            dump_string<Format>(settings, "VkSemaphoreSignalInfo");
+            dump_value(api_dump, "VkSemaphoreSignalInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceBufferDeviceAddressFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceBufferDeviceAddressFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
-            dump_string<Format>(settings, "VkBufferDeviceAddressInfo");
+            dump_value(api_dump, "VkBufferDeviceAddressInfo");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
-            dump_string<Format>(settings, "VkBufferOpaqueCaptureAddressCreateInfo");
+            dump_value(api_dump, "VkBufferOpaqueCaptureAddressCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkMemoryOpaqueCaptureAddressAllocateInfo");
+            dump_value(api_dump, "VkMemoryOpaqueCaptureAddressAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
-            dump_string<Format>(settings, "VkDeviceMemoryOpaqueCaptureAddressInfo");
+            dump_value(api_dump, "VkDeviceMemoryOpaqueCaptureAddressInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDevice8BitStorageFeatures");
+            dump_value(api_dump, "VkPhysicalDevice8BitStorageFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicInt64Features");
+            dump_value(api_dump, "VkPhysicalDeviceShaderAtomicInt64Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderFloat16Int8Features");
+            dump_value(api_dump, "VkPhysicalDeviceShaderFloat16Int8Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceFloatControlsProperties");
+            dump_value(api_dump, "VkPhysicalDeviceFloatControlsProperties");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorSetLayoutBindingFlagsCreateInfo");
+            dump_value(api_dump, "VkDescriptorSetLayoutBindingFlagsCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorIndexingFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorIndexingFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorIndexingProperties");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorIndexingProperties");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorSetVariableDescriptorCountAllocateInfo");
+            dump_value(api_dump, "VkDescriptorSetVariableDescriptorCountAllocateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
-            dump_string<Format>(settings, "VkDescriptorSetVariableDescriptorCountLayoutSupport");
+            dump_value(api_dump, "VkDescriptorSetVariableDescriptorCountLayoutSupport");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceScalarBlockLayoutFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceScalarBlockLayoutFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
-            dump_string<Format>(settings, "VkSamplerReductionModeCreateInfo");
+            dump_value(api_dump, "VkSamplerReductionModeCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSamplerFilterMinmaxProperties");
+            dump_value(api_dump, "VkPhysicalDeviceSamplerFilterMinmaxProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
-            dump_string<Format>(settings, "VkAttachmentDescription2");
+            dump_value(api_dump, "VkAttachmentDescription2");
             break;
 
         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
-            dump_string<Format>(settings, "VkAttachmentReference2");
+            dump_value(api_dump, "VkAttachmentReference2");
             break;
 
         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
-            dump_string<Format>(settings, "VkSubpassDescription2");
+            dump_value(api_dump, "VkSubpassDescription2");
             break;
 
         case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
-            dump_string<Format>(settings, "VkSubpassDependency2");
+            dump_value(api_dump, "VkSubpassDependency2");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
-            dump_string<Format>(settings, "VkRenderPassCreateInfo2");
+            dump_value(api_dump, "VkRenderPassCreateInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
-            dump_string<Format>(settings, "VkSubpassBeginInfo");
+            dump_value(api_dump, "VkSubpassBeginInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
-            dump_string<Format>(settings, "VkSubpassEndInfo");
+            dump_value(api_dump, "VkSubpassEndInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
-            dump_string<Format>(settings, "VkSubpassDescriptionDepthStencilResolve");
+            dump_value(api_dump, "VkSubpassDescriptionDepthStencilResolve");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceDepthStencilResolveProperties");
+            dump_value(api_dump, "VkPhysicalDeviceDepthStencilResolveProperties");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
-            dump_string<Format>(settings, "VkImageStencilUsageCreateInfo");
+            dump_value(api_dump, "VkImageStencilUsageCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceImagelessFramebufferFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceImagelessFramebufferFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
-            dump_string<Format>(settings, "VkFramebufferAttachmentImageInfo");
+            dump_value(api_dump, "VkFramebufferAttachmentImageInfo");
             break;
 
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-            dump_string<Format>(settings, "VkFramebufferAttachmentsCreateInfo");
+            dump_value(api_dump, "VkFramebufferAttachmentsCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
-            dump_string<Format>(settings, "VkRenderPassAttachmentBeginInfo");
+            dump_value(api_dump, "VkRenderPassAttachmentBeginInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
-            dump_string<Format>(settings, "VkAttachmentReferenceStencilLayout");
+            dump_value(api_dump, "VkAttachmentReferenceStencilLayout");
             break;
 
         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
-            dump_string<Format>(settings, "VkAttachmentDescriptionStencilLayout");
+            dump_value(api_dump, "VkAttachmentDescriptionStencilLayout");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan13Features");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan13Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan13Properties");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan13Properties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceToolProperties");
+            dump_value(api_dump, "VkPhysicalDeviceToolProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDevicePrivateDataFeatures");
+            dump_value(api_dump, "VkPhysicalDevicePrivateDataFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
-            dump_string<Format>(settings, "VkDevicePrivateDataCreateInfo");
+            dump_value(api_dump, "VkDevicePrivateDataCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
-            dump_string<Format>(settings, "VkPrivateDataSlotCreateInfo");
+            dump_value(api_dump, "VkPrivateDataSlotCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
-            dump_string<Format>(settings, "VkMemoryBarrier2");
+            dump_value(api_dump, "VkMemoryBarrier2");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
-            dump_string<Format>(settings, "VkBufferMemoryBarrier2");
+            dump_value(api_dump, "VkBufferMemoryBarrier2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
-            dump_string<Format>(settings, "VkImageMemoryBarrier2");
+            dump_value(api_dump, "VkImageMemoryBarrier2");
             break;
 
         case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
-            dump_string<Format>(settings, "VkDependencyInfo");
+            dump_value(api_dump, "VkDependencyInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
-            dump_string<Format>(settings, "VkSemaphoreSubmitInfo");
+            dump_value(api_dump, "VkSemaphoreSubmitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
-            dump_string<Format>(settings, "VkCommandBufferSubmitInfo");
+            dump_value(api_dump, "VkCommandBufferSubmitInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
-            dump_string<Format>(settings, "VkSubmitInfo2");
+            dump_value(api_dump, "VkSubmitInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSynchronization2Features");
+            dump_value(api_dump, "VkPhysicalDeviceSynchronization2Features");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
-            dump_string<Format>(settings, "VkBufferCopy2");
+            dump_value(api_dump, "VkBufferCopy2");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
-            dump_string<Format>(settings, "VkCopyBufferInfo2");
+            dump_value(api_dump, "VkCopyBufferInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
-            dump_string<Format>(settings, "VkImageCopy2");
+            dump_value(api_dump, "VkImageCopy2");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
-            dump_string<Format>(settings, "VkCopyImageInfo2");
+            dump_value(api_dump, "VkCopyImageInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
-            dump_string<Format>(settings, "VkBufferImageCopy2");
+            dump_value(api_dump, "VkBufferImageCopy2");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
-            dump_string<Format>(settings, "VkCopyBufferToImageInfo2");
+            dump_value(api_dump, "VkCopyBufferToImageInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
-            dump_string<Format>(settings, "VkCopyImageToBufferInfo2");
+            dump_value(api_dump, "VkCopyImageToBufferInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceTextureCompressionASTCHDRFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceTextureCompressionASTCHDRFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
-            dump_string<Format>(settings, "VkFormatProperties3");
+            dump_value(api_dump, "VkFormatProperties3");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance4Features");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance4Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance4Properties");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance4Properties");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
-            dump_string<Format>(settings, "VkDeviceBufferMemoryRequirements");
+            dump_value(api_dump, "VkDeviceBufferMemoryRequirements");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
-            dump_string<Format>(settings, "VkDeviceImageMemoryRequirements");
+            dump_value(api_dump, "VkDeviceImageMemoryRequirements");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineCreationFeedbackCreateInfo");
+            dump_value(api_dump, "VkPipelineCreationFeedbackCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderTerminateInvocationFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderTerminateInvocationFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineCreationCacheControlFeatures");
+            dump_value(api_dump, "VkPhysicalDevicePipelineCreationCacheControlFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageRobustnessFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceImageRobustnessFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSubgroupSizeControlFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceSubgroupSizeControlFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceSubgroupSizeControlProperties");
+            dump_value(api_dump, "VkPhysicalDeviceSubgroupSizeControlProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo");
+            dump_value(api_dump, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceInlineUniformBlockFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceInlineUniformBlockFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceInlineUniformBlockProperties");
+            dump_value(api_dump, "VkPhysicalDeviceInlineUniformBlockProperties");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
-            dump_string<Format>(settings, "VkWriteDescriptorSetInlineUniformBlock");
+            dump_value(api_dump, "VkWriteDescriptorSetInlineUniformBlock");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
-            dump_string<Format>(settings, "VkDescriptorPoolInlineUniformBlockCreateInfo");
+            dump_value(api_dump, "VkDescriptorPoolInlineUniformBlockCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderIntegerDotProductFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderIntegerDotProductFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderIntegerDotProductProperties");
+            dump_value(api_dump, "VkPhysicalDeviceShaderIntegerDotProductProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceTexelBufferAlignmentProperties");
+            dump_value(api_dump, "VkPhysicalDeviceTexelBufferAlignmentProperties");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
-            dump_string<Format>(settings, "VkImageBlit2");
+            dump_value(api_dump, "VkImageBlit2");
             break;
 
         case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
-            dump_string<Format>(settings, "VkBlitImageInfo2");
+            dump_value(api_dump, "VkBlitImageInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
-            dump_string<Format>(settings, "VkImageResolve2");
+            dump_value(api_dump, "VkImageResolve2");
             break;
 
         case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
-            dump_string<Format>(settings, "VkResolveImageInfo2");
+            dump_value(api_dump, "VkResolveImageInfo2");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
-            dump_string<Format>(settings, "VkRenderingAttachmentInfo");
+            dump_value(api_dump, "VkRenderingAttachmentInfo");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_INFO:
-            dump_string<Format>(settings, "VkRenderingInfo");
+            dump_value(api_dump, "VkRenderingInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineRenderingCreateInfo");
+            dump_value(api_dump, "VkPipelineRenderingCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceDynamicRenderingFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceDynamicRenderingFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
-            dump_string<Format>(settings, "VkCommandBufferInheritanceRenderingInfo");
+            dump_value(api_dump, "VkCommandBufferInheritanceRenderingInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan14Features");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan14Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVulkan14Properties");
+            dump_value(api_dump, "VkPhysicalDeviceVulkan14Properties");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
-            dump_string<Format>(settings, "VkDeviceQueueGlobalPriorityCreateInfo");
+            dump_value(api_dump, "VkDeviceQueueGlobalPriorityCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceGlobalPriorityQueryFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceGlobalPriorityQueryFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
-            dump_string<Format>(settings, "VkQueueFamilyGlobalPriorityProperties");
+            dump_value(api_dump, "VkQueueFamilyGlobalPriorityProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceIndexTypeUint8Features");
+            dump_value(api_dump, "VkPhysicalDeviceIndexTypeUint8Features");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO:
-            dump_string<Format>(settings, "VkMemoryMapInfo");
+            dump_value(api_dump, "VkMemoryMapInfo");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO:
-            dump_string<Format>(settings, "VkMemoryUnmapInfo");
+            dump_value(api_dump, "VkMemoryUnmapInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance5Features");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance5Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance5Properties");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance5Properties");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
-            dump_string<Format>(settings, "VkImageSubresource2");
+            dump_value(api_dump, "VkImageSubresource2");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
-            dump_string<Format>(settings, "VkDeviceImageSubresourceInfo");
+            dump_value(api_dump, "VkDeviceImageSubresourceInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
-            dump_string<Format>(settings, "VkSubresourceLayout2");
+            dump_value(api_dump, "VkSubresourceLayout2");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
-            dump_string<Format>(settings, "VkBufferUsageFlags2CreateInfo");
+            dump_value(api_dump, "VkBufferUsageFlags2CreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance6Features");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance6Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance6Properties");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance6Properties");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
-            dump_string<Format>(settings, "VkBindMemoryStatus");
+            dump_value(api_dump, "VkBindMemoryStatus");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceHostImageCopyFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceHostImageCopyFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceHostImageCopyProperties");
+            dump_value(api_dump, "VkPhysicalDeviceHostImageCopyProperties");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY:
-            dump_string<Format>(settings, "VkMemoryToImageCopy");
+            dump_value(api_dump, "VkMemoryToImageCopy");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY:
-            dump_string<Format>(settings, "VkImageToMemoryCopy");
+            dump_value(api_dump, "VkImageToMemoryCopy");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO:
-            dump_string<Format>(settings, "VkCopyMemoryToImageInfo");
+            dump_value(api_dump, "VkCopyMemoryToImageInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO:
-            dump_string<Format>(settings, "VkCopyImageToMemoryInfo");
+            dump_value(api_dump, "VkCopyImageToMemoryInfo");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO:
-            dump_string<Format>(settings, "VkCopyImageToImageInfo");
+            dump_value(api_dump, "VkCopyImageToImageInfo");
             break;
 
         case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO:
-            dump_string<Format>(settings, "VkHostImageLayoutTransitionInfo");
+            dump_value(api_dump, "VkHostImageLayoutTransitionInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
-            dump_string<Format>(settings, "VkSubresourceHostMemcpySize");
+            dump_value(api_dump, "VkSubresourceHostMemcpySize");
             break;
 
         case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
-            dump_string<Format>(settings, "VkHostImageCopyDevicePerformanceQuery");
+            dump_value(api_dump, "VkHostImageCopyDevicePerformanceQuery");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupRotateFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderSubgroupRotateFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderFloatControls2Features");
+            dump_value(api_dump, "VkPhysicalDeviceShaderFloatControls2Features");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderExpectAssumeFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceShaderExpectAssumeFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineCreateFlags2CreateInfo");
+            dump_value(api_dump, "VkPipelineCreateFlags2CreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDevicePushDescriptorProperties");
+            dump_value(api_dump, "VkPhysicalDevicePushDescriptorProperties");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
-            dump_string<Format>(settings, "VkBindDescriptorSetsInfo");
+            dump_value(api_dump, "VkBindDescriptorSetsInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO:
-            dump_string<Format>(settings, "VkPushConstantsInfo");
+            dump_value(api_dump, "VkPushConstantsInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
-            dump_string<Format>(settings, "VkPushDescriptorSetInfo");
+            dump_value(api_dump, "VkPushDescriptorSetInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO:
-            dump_string<Format>(settings, "VkPushDescriptorSetWithTemplateInfo");
+            dump_value(api_dump, "VkPushDescriptorSetWithTemplateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineProtectedAccessFeatures");
+            dump_value(api_dump, "VkPhysicalDevicePipelineProtectedAccessFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineRobustnessFeatures");
+            dump_value(api_dump, "VkPhysicalDevicePipelineRobustnessFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineRobustnessProperties");
+            dump_value(api_dump, "VkPhysicalDevicePipelineRobustnessProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineRobustnessCreateInfo");
+            dump_value(api_dump, "VkPipelineRobustnessCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceLineRasterizationFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceLineRasterizationFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceLineRasterizationProperties");
+            dump_value(api_dump, "VkPhysicalDeviceLineRasterizationProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineRasterizationLineStateCreateInfo");
+            dump_value(api_dump, "VkPipelineRasterizationLineStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeDivisorProperties");
+            dump_value(api_dump, "VkPhysicalDeviceVertexAttributeDivisorProperties");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
-            dump_string<Format>(settings, "VkPipelineVertexInputDivisorStateCreateInfo");
+            dump_value(api_dump, "VkPipelineVertexInputDivisorStateCreateInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeDivisorFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceVertexAttributeDivisorFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO:
-            dump_string<Format>(settings, "VkRenderingAreaInfo");
+            dump_value(api_dump, "VkRenderingAreaInfo");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
-            dump_string<Format>(settings, "VkPhysicalDeviceDynamicRenderingLocalReadFeatures");
+            dump_value(api_dump, "VkPhysicalDeviceDynamicRenderingLocalReadFeatures");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
-            dump_string<Format>(settings, "VkRenderingAttachmentLocationInfo");
+            dump_value(api_dump, "VkRenderingAttachmentLocationInfo");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
-            dump_string<Format>(settings, "VkRenderingInputAttachmentIndexInfo");
+            dump_value(api_dump, "VkRenderingInputAttachmentIndexInfo");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkSwapchainCreateInfoKHR");
+            dump_value(api_dump, "VkSwapchainCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
-            dump_string<Format>(settings, "VkPresentInfoKHR");
+            dump_value(api_dump, "VkPresentInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkImageSwapchainCreateInfoKHR");
+            dump_value(api_dump, "VkImageSwapchainCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
-            dump_string<Format>(settings, "VkBindImageMemorySwapchainInfoKHR");
+            dump_value(api_dump, "VkBindImageMemorySwapchainInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
-            dump_string<Format>(settings, "VkAcquireNextImageInfoKHR");
+            dump_value(api_dump, "VkAcquireNextImageInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkDeviceGroupPresentCapabilitiesKHR");
+            dump_value(api_dump, "VkDeviceGroupPresentCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
-            dump_string<Format>(settings, "VkDeviceGroupPresentInfoKHR");
+            dump_value(api_dump, "VkDeviceGroupPresentInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkDeviceGroupSwapchainCreateInfoKHR");
+            dump_value(api_dump, "VkDeviceGroupSwapchainCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkDisplayModeCreateInfoKHR");
+            dump_value(api_dump, "VkDisplayModeCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkDisplaySurfaceCreateInfoKHR");
+            dump_value(api_dump, "VkDisplaySurfaceCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
-            dump_string<Format>(settings, "VkDisplayPresentInfoKHR");
+            dump_value(api_dump, "VkDisplayPresentInfoKHR");
             break;
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
 
         case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkXlibSurfaceCreateInfoKHR");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "VkWin32SurfaceCreateInfoKHR");
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkQueueFamilyQueryResultStatusPropertiesKHR");
+            dump_value(api_dump, "VkQueueFamilyQueryResultStatusPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkQueueFamilyVideoPropertiesKHR");
+            dump_value(api_dump, "VkQueueFamilyVideoPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoProfileInfoKHR");
+            dump_value(api_dump, "VkVideoProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoProfileListInfoKHR");
+            dump_value(api_dump, "VkVideoProfileListInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoFormatInfoKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoFormatInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoFormatPropertiesKHR");
+            dump_value(api_dump, "VkVideoFormatPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoPictureResourceInfoKHR");
+            dump_value(api_dump, "VkVideoPictureResourceInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoReferenceSlotInfoKHR");
+            dump_value(api_dump, "VkVideoReferenceSlotInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR:
-            dump_string<Format>(settings, "VkVideoSessionMemoryRequirementsKHR");
+            dump_value(api_dump, "VkVideoSessionMemoryRequirementsKHR");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR:
-            dump_string<Format>(settings, "VkBindVideoSessionMemoryInfoKHR");
+            dump_value(api_dump, "VkBindVideoSessionMemoryInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoSessionCreateInfoKHR");
+            dump_value(api_dump, "VkVideoSessionCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoSessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoSessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoSessionParametersUpdateInfoKHR");
+            dump_value(api_dump, "VkVideoSessionParametersUpdateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoBeginCodingInfoKHR");
+            dump_value(api_dump, "VkVideoBeginCodingInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEndCodingInfoKHR");
+            dump_value(api_dump, "VkVideoEndCodingInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoCodingControlInfoKHR");
+            dump_value(api_dump, "VkVideoCodingControlInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoDecodeCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeUsageInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeUsageInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeH264CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264QualityLevelPropertiesKHR");
+            dump_value(api_dump, "VkVideoEncodeH264QualityLevelPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264SessionCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264SessionCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersAddInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264SessionParametersAddInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264SessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersGetInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264SessionParametersGetInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersFeedbackInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264SessionParametersFeedbackInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264NaluSliceInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264NaluSliceInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264PictureInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264DpbSlotInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264DpbSlotInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264RateControlInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264RateControlInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264RateControlLayerInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264RateControlLayerInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264GopRemainingFrameInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH264GopRemainingFrameInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeH265CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265SessionCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265SessionCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265QualityLevelPropertiesKHR");
+            dump_value(api_dump, "VkVideoEncodeH265QualityLevelPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersAddInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265SessionParametersAddInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265SessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersGetInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265SessionParametersGetInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersFeedbackInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265SessionParametersFeedbackInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265NaluSliceSegmentInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265NaluSliceSegmentInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265PictureInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265DpbSlotInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265DpbSlotInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265RateControlInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265RateControlInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265RateControlLayerInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265RateControlLayerInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265GopRemainingFrameInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeH265GopRemainingFrameInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH264ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoDecodeH264CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264SessionParametersAddInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH264SessionParametersAddInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264SessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH264SessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264PictureInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH264PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264DpbSlotInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH264DpbSlotInfoKHR");
             break;
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkImportMemoryWin32HandleInfoKHR");
+            dump_value(api_dump, "VkImportMemoryWin32HandleInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkExportMemoryWin32HandleInfoKHR");
+            dump_value(api_dump, "VkExportMemoryWin32HandleInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkMemoryWin32HandlePropertiesKHR");
+            dump_value(api_dump, "VkMemoryWin32HandlePropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkMemoryGetWin32HandleInfoKHR");
+            dump_value(api_dump, "VkMemoryGetWin32HandleInfoKHR");
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
-            dump_string<Format>(settings, "VkImportMemoryFdInfoKHR");
+            dump_value(api_dump, "VkImportMemoryFdInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkMemoryFdPropertiesKHR");
+            dump_value(api_dump, "VkMemoryFdPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
-            dump_string<Format>(settings, "VkMemoryGetFdInfoKHR");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "VkWin32KeyedMutexAcquireReleaseInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkImportSemaphoreWin32HandleInfoKHR");
+            dump_value(api_dump, "VkImportSemaphoreWin32HandleInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkExportSemaphoreWin32HandleInfoKHR");
+            dump_value(api_dump, "VkExportSemaphoreWin32HandleInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
-            dump_string<Format>(settings, "VkD3D12FenceSubmitInfoKHR");
+            dump_value(api_dump, "VkD3D12FenceSubmitInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkSemaphoreGetWin32HandleInfoKHR");
+            dump_value(api_dump, "VkSemaphoreGetWin32HandleInfoKHR");
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
         case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
-            dump_string<Format>(settings, "VkImportSemaphoreFdInfoKHR");
+            dump_value(api_dump, "VkImportSemaphoreFdInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
-            dump_string<Format>(settings, "VkSemaphoreGetFdInfoKHR");
+            dump_value(api_dump, "VkSemaphoreGetFdInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
-            dump_string<Format>(settings, "VkPresentRegionsKHR");
+            dump_value(api_dump, "VkPresentRegionsKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkSharedPresentSurfaceCapabilitiesKHR");
+            dump_value(api_dump, "VkSharedPresentSurfaceCapabilitiesKHR");
             break;
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
 
         case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkImportFenceWin32HandleInfoKHR");
+            dump_value(api_dump, "VkImportFenceWin32HandleInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkExportFenceWin32HandleInfoKHR");
+            dump_value(api_dump, "VkExportFenceWin32HandleInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
-            dump_string<Format>(settings, "VkFenceGetWin32HandleInfoKHR");
+            dump_value(api_dump, "VkFenceGetWin32HandleInfoKHR");
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
         case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
-            dump_string<Format>(settings, "VkImportFenceFdInfoKHR");
+            dump_value(api_dump, "VkImportFenceFdInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
-            dump_string<Format>(settings, "VkFenceGetFdInfoKHR");
+            dump_value(api_dump, "VkFenceGetFdInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePerformanceQueryFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePerformanceQueryFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePerformanceQueryPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePerformanceQueryPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
-            dump_string<Format>(settings, "VkPerformanceCounterKHR");
+            dump_value(api_dump, "VkPerformanceCounterKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
-            dump_string<Format>(settings, "VkPerformanceCounterDescriptionKHR");
+            dump_value(api_dump, "VkPerformanceCounterDescriptionKHR");
             break;
 
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkQueryPoolPerformanceCreateInfoKHR");
+            dump_value(api_dump, "VkQueryPoolPerformanceCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
-            dump_string<Format>(settings, "VkAcquireProfilingLockInfoKHR");
+            dump_value(api_dump, "VkAcquireProfilingLockInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
-            dump_string<Format>(settings, "VkPerformanceQuerySubmitInfoKHR");
+            dump_value(api_dump, "VkPerformanceQuerySubmitInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceSurfaceInfo2KHR");
+            dump_value(api_dump, "VkPhysicalDeviceSurfaceInfo2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
-            dump_string<Format>(settings, "VkSurfaceCapabilities2KHR");
+            dump_value(api_dump, "VkSurfaceCapabilities2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
-            dump_string<Format>(settings, "VkSurfaceFormat2KHR");
+            dump_value(api_dump, "VkSurfaceFormat2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
-            dump_string<Format>(settings, "VkDisplayProperties2KHR");
+            dump_value(api_dump, "VkDisplayProperties2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
-            dump_string<Format>(settings, "VkDisplayPlaneProperties2KHR");
+            dump_value(api_dump, "VkDisplayPlaneProperties2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
-            dump_string<Format>(settings, "VkDisplayModeProperties2KHR");
+            dump_value(api_dump, "VkDisplayModeProperties2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
-            dump_string<Format>(settings, "VkDisplayPlaneInfo2KHR");
+            dump_value(api_dump, "VkDisplayPlaneInfo2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
-            dump_string<Format>(settings, "VkDisplayPlaneCapabilities2KHR");
+            dump_value(api_dump, "VkDisplayPlaneCapabilities2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderBfloat16FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderBfloat16FeaturesKHR");
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePortabilitySubsetFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePortabilitySubsetFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePortabilitySubsetPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePortabilitySubsetPropertiesKHR");
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderClockFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderClockFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH265ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoDecodeH265CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265SessionParametersAddInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH265SessionParametersAddInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265SessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH265SessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265PictureInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH265PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265DpbSlotInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH265DpbSlotInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-            dump_string<Format>(settings, "VkFragmentShadingRateAttachmentInfoKHR");
+            dump_value(api_dump, "VkFragmentShadingRateAttachmentInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineFragmentShadingRateStateCreateInfoKHR");
+            dump_value(api_dump, "VkPipelineFragmentShadingRateStateCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateKHR");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShadingRateKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-            dump_string<Format>(settings, "VkRenderingFragmentShadingRateAttachmentInfoKHR");
+            dump_value(api_dump, "VkRenderingFragmentShadingRateAttachmentInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderQuadControlFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderQuadControlFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkSurfaceProtectedCapabilitiesKHR");
+            dump_value(api_dump, "VkSurfaceProtectedCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentWaitFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePresentWaitFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineInfoKHR");
+            dump_value(api_dump, "VkPipelineInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPipelineExecutablePropertiesKHR");
+            dump_value(api_dump, "VkPipelineExecutablePropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineExecutableInfoKHR");
+            dump_value(api_dump, "VkPipelineExecutableInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
-            dump_string<Format>(settings, "VkPipelineExecutableStatisticKHR");
+            dump_value(api_dump, "VkPipelineExecutableStatisticKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
-            dump_string<Format>(settings, "VkPipelineExecutableInternalRepresentationKHR");
+            dump_value(api_dump, "VkPipelineExecutableInternalRepresentationKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineLibraryCreateInfoKHR");
+            dump_value(api_dump, "VkPipelineLibraryCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
-            dump_string<Format>(settings, "VkPresentIdKHR");
+            dump_value(api_dump, "VkPresentIdKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentIdFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePresentIdFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR");
+            dump_value(api_dump, "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeUsageInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeUsageInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeRateControlLayerInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeRateControlLayerInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeRateControlInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeRateControlInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeQualityLevelPropertiesKHR");
+            dump_value(api_dump, "VkVideoEncodeQualityLevelPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeQualityLevelInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeQualityLevelInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeSessionParametersGetInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeSessionParametersGetInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeSessionParametersFeedbackInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
-            dump_string<Format>(settings, "VkSurfaceCapabilitiesPresentId2KHR");
+            dump_value(api_dump, "VkSurfaceCapabilitiesPresentId2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
-            dump_string<Format>(settings, "VkPresentId2KHR");
+            dump_value(api_dump, "VkPresentId2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentId2FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePresentId2FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
-            dump_string<Format>(settings, "VkSurfaceCapabilitiesPresentWait2KHR");
+            dump_value(api_dump, "VkSurfaceCapabilitiesPresentWait2KHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentWait2FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePresentWait2FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR:
-            dump_string<Format>(settings, "VkPresentWait2InfoKHR");
+            dump_value(api_dump, "VkPresentWait2InfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineBinaryFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePipelineBinaryFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineBinaryPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePipelineBinaryPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
-            dump_string<Format>(settings, "VkDevicePipelineBinaryInternalCacheControlKHR");
+            dump_value(api_dump, "VkDevicePipelineBinaryInternalCacheControlKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR:
-            dump_string<Format>(settings, "VkPipelineBinaryKeyKHR");
+            dump_value(api_dump, "VkPipelineBinaryKeyKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineCreateInfoKHR");
+            dump_value(api_dump, "VkPipelineCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineBinaryCreateInfoKHR");
+            dump_value(api_dump, "VkPipelineBinaryCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineBinaryInfoKHR");
+            dump_value(api_dump, "VkPipelineBinaryInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR:
-            dump_string<Format>(settings, "VkReleaseCapturedPipelineDataInfoKHR");
+            dump_value(api_dump, "VkReleaseCapturedPipelineDataInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineBinaryDataInfoKHR");
+            dump_value(api_dump, "VkPipelineBinaryDataInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
-            dump_string<Format>(settings, "VkPipelineBinaryHandlesInfoKHR");
+            dump_value(api_dump, "VkPipelineBinaryHandlesInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
-            dump_string<Format>(settings, "VkSurfacePresentModeKHR");
+            dump_value(api_dump, "VkSurfacePresentModeKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkSurfacePresentScalingCapabilitiesKHR");
+            dump_value(api_dump, "VkSurfacePresentScalingCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
-            dump_string<Format>(settings, "VkSurfacePresentModeCompatibilityKHR");
+            dump_value(api_dump, "VkSurfacePresentModeCompatibilityKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
-            dump_string<Format>(settings, "VkSwapchainPresentFenceInfoKHR");
+            dump_value(api_dump, "VkSwapchainPresentFenceInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkSwapchainPresentModesCreateInfoKHR");
+            dump_value(api_dump, "VkSwapchainPresentModesCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
-            dump_string<Format>(settings, "VkSwapchainPresentModeInfoKHR");
+            dump_value(api_dump, "VkSwapchainPresentModeInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkSwapchainPresentScalingCreateInfoKHR");
+            dump_value(api_dump, "VkSwapchainPresentScalingCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR:
-            dump_string<Format>(settings, "VkReleaseSwapchainImagesInfoKHR");
+            dump_value(api_dump, "VkReleaseSwapchainImagesInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkCooperativeMatrixPropertiesKHR");
+            dump_value(api_dump, "VkCooperativeMatrixPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrixPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeAV1ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeAV1ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeAV1CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoDecodeAV1CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeAV1SessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeAV1SessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeAV1PictureInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeAV1PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeAV1DpbSlotInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeAV1DpbSlotInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1QualityLevelPropertiesKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1QualityLevelPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1SessionCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1SessionCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1SessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1SessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1PictureInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1DpbSlotInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1DpbSlotInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1GopRemainingFrameInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1GopRemainingFrameInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1RateControlInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1RateControlInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1RateControlLayerInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1RateControlLayerInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeVP9ProfileInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeVP9ProfileInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeVP9CapabilitiesKHR");
+            dump_value(api_dump, "VkVideoDecodeVP9CapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeVP9PictureInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeVP9PictureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoInlineQueryInfoKHR");
+            dump_value(api_dump, "VkVideoInlineQueryInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
-            dump_string<Format>(settings, "VkAttachmentFeedbackLoopInfoEXT");
+            dump_value(api_dump, "VkAttachmentFeedbackLoopInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
-            dump_string<Format>(settings, "VkCalibratedTimestampInfoKHR");
+            dump_value(api_dump, "VkCalibratedTimestampInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
-            dump_string<Format>(settings, "VkSetDescriptorBufferOffsetsInfoEXT");
+            dump_value(api_dump, "VkSetDescriptorBufferOffsetsInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
-            dump_string<Format>(settings, "VkBindDescriptorBufferEmbeddedSamplersInfoEXT");
+            dump_value(api_dump, "VkBindDescriptorBufferEmbeddedSamplersInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR:
-            dump_string<Format>(settings, "VkCopyMemoryIndirectInfoKHR");
+            dump_value(api_dump, "VkCopyMemoryIndirectInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR:
-            dump_string<Format>(settings, "VkCopyMemoryToImageIndirectInfoKHR");
+            dump_value(api_dump, "VkCopyMemoryToImageIndirectInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeIntraRefreshCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeIntraRefreshCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeSessionIntraRefreshCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeSessionIntraRefreshCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeIntraRefreshInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeIntraRefreshInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoReferenceIntraRefreshInfoKHR");
+            dump_value(api_dump, "VkVideoReferenceIntraRefreshInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeQuantizationMapCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeQuantizationMapCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoFormatQuantizationMapPropertiesKHR");
+            dump_value(api_dump, "VkVideoFormatQuantizationMapPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeQuantizationMapInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeQuantizationMapInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR");
+            dump_value(api_dump, "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH264QuantizationMapCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeH264QuantizationMapCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeH265QuantizationMapCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeH265QuantizationMapCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoFormatH265QuantizationMapPropertiesKHR");
+            dump_value(api_dump, "VkVideoFormatH265QuantizationMapPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
-            dump_string<Format>(settings, "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR");
+            dump_value(api_dump, "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkVideoFormatAV1QuantizationMapPropertiesKHR");
+            dump_value(api_dump, "VkVideoFormatAV1QuantizationMapPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance7FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance7FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance7PropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance7PropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceLayeredApiPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceLayeredApiPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceLayeredApiPropertiesListKHR");
+            dump_value(api_dump, "VkPhysicalDeviceLayeredApiPropertiesListKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
-            dump_string<Format>(settings, "VkMemoryBarrierAccessFlags3KHR");
+            dump_value(api_dump, "VkMemoryBarrierAccessFlags3KHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance8FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance8FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderFmaFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceShaderFmaFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance9FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance9FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance9PropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance9PropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkQueueFamilyOwnershipTransferPropertiesKHR");
+            dump_value(api_dump, "VkQueueFamilyOwnershipTransferPropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoMaintenance2FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceVideoMaintenance2FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH264InlineSessionParametersInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH264InlineSessionParametersInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeH265InlineSessionParametersInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeH265InlineSessionParametersInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
-            dump_string<Format>(settings, "VkVideoDecodeAV1InlineSessionParametersInfoKHR");
+            dump_value(api_dump, "VkVideoDecodeAV1InlineSessionParametersInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRobustness2FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRobustness2FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRobustness2PropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRobustness2PropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance10FeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance10FeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance10PropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceMaintenance10PropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR:
-            dump_string<Format>(settings, "VkRenderingEndInfoKHR");
+            dump_value(api_dump, "VkRenderingEndInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR:
-            dump_string<Format>(settings, "VkRenderingAttachmentFlagsInfoKHR");
+            dump_value(api_dump, "VkRenderingAttachmentFlagsInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR:
-            dump_string<Format>(settings, "VkResolveImageModeInfoKHR");
+            dump_value(api_dump, "VkResolveImageModeInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugReportCallbackCreateInfoEXT");
+            dump_value(api_dump, "VkDebugReportCallbackCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
-            dump_string<Format>(settings, "VkPipelineRasterizationStateRasterizationOrderAMD");
+            dump_value(api_dump, "VkPipelineRasterizationStateRasterizationOrderAMD");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugMarkerObjectNameInfoEXT");
+            dump_value(api_dump, "VkDebugMarkerObjectNameInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugMarkerObjectTagInfoEXT");
+            dump_value(api_dump, "VkDebugMarkerObjectTagInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugMarkerMarkerInfoEXT");
+            dump_value(api_dump, "VkDebugMarkerMarkerInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkDedicatedAllocationImageCreateInfoNV");
+            dump_value(api_dump, "VkDedicatedAllocationImageCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkDedicatedAllocationBufferCreateInfoNV");
+            dump_value(api_dump, "VkDedicatedAllocationBufferCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
-            dump_string<Format>(settings, "VkDedicatedAllocationMemoryAllocateInfoNV");
+            dump_value(api_dump, "VkDedicatedAllocationMemoryAllocateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceTransformFeedbackFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceTransformFeedbackFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceTransformFeedbackPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceTransformFeedbackPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineRasterizationStateStreamCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineRasterizationStateStreamCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
-            dump_string<Format>(settings, "VkCuModuleCreateInfoNVX");
+            dump_value(api_dump, "VkCuModuleCreateInfoNVX");
             break;
 
         case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
-            dump_string<Format>(settings, "VkCuModuleTexturingModeCreateInfoNVX");
+            dump_value(api_dump, "VkCuModuleTexturingModeCreateInfoNVX");
             break;
 
         case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
-            dump_string<Format>(settings, "VkCuFunctionCreateInfoNVX");
+            dump_value(api_dump, "VkCuFunctionCreateInfoNVX");
             break;
 
         case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
-            dump_string<Format>(settings, "VkCuLaunchInfoNVX");
+            dump_value(api_dump, "VkCuLaunchInfoNVX");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
-            dump_string<Format>(settings, "VkImageViewHandleInfoNVX");
+            dump_value(api_dump, "VkImageViewHandleInfoNVX");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
-            dump_string<Format>(settings, "VkImageViewAddressPropertiesNVX");
+            dump_value(api_dump, "VkImageViewAddressPropertiesNVX");
             break;
 
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
-            dump_string<Format>(settings, "VkTextureLODGatherFormatPropertiesAMD");
+            dump_value(api_dump, "VkTextureLODGatherFormatPropertiesAMD");
             break;
 #if defined(VK_USE_PLATFORM_GGP)
 
         case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
-            dump_string<Format>(settings, "VkStreamDescriptorSurfaceCreateInfoGGP");
+            dump_value(api_dump, "VkStreamDescriptorSurfaceCreateInfoGGP");
             break;
 #endif  // VK_USE_PLATFORM_GGP
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCornerSampledImageFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCornerSampledImageFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkExternalMemoryImageCreateInfoNV");
+            dump_value(api_dump, "VkExternalMemoryImageCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
-            dump_string<Format>(settings, "VkExportMemoryAllocateInfoNV");
+            dump_value(api_dump, "VkExportMemoryAllocateInfoNV");
             break;
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
-            dump_string<Format>(settings, "VkImportMemoryWin32HandleInfoNV");
+            dump_value(api_dump, "VkImportMemoryWin32HandleInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
-            dump_string<Format>(settings, "VkExportMemoryWin32HandleInfoNV");
+            dump_value(api_dump, "VkExportMemoryWin32HandleInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
-            dump_string<Format>(settings, "VkWin32KeyedMutexAcquireReleaseInfoNV");
+            dump_value(api_dump, "VkWin32KeyedMutexAcquireReleaseInfoNV");
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
-            dump_string<Format>(settings, "VkValidationFlagsEXT");
+            dump_value(api_dump, "VkValidationFlagsEXT");
             break;
 #if defined(VK_USE_PLATFORM_VI_NN)
 
         case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
-            dump_string<Format>(settings, "VkViSurfaceCreateInfoNN");
+            dump_value(api_dump, "VkViSurfaceCreateInfoNN");
             break;
 #endif  // VK_USE_PLATFORM_VI_NN
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
-            dump_string<Format>(settings, "VkImageViewASTCDecodeModeEXT");
+            dump_value(api_dump, "VkImageViewASTCDecodeModeEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceASTCDecodeFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceASTCDecodeFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
-            dump_string<Format>(settings, "VkConditionalRenderingBeginInfoEXT");
+            dump_value(api_dump, "VkConditionalRenderingBeginInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceConditionalRenderingFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceConditionalRenderingFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
-            dump_string<Format>(settings, "VkCommandBufferInheritanceConditionalRenderingInfoEXT");
+            dump_value(api_dump, "VkCommandBufferInheritanceConditionalRenderingInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineViewportWScalingStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineViewportWScalingStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
-            dump_string<Format>(settings, "VkSurfaceCapabilities2EXT");
+            dump_value(api_dump, "VkSurfaceCapabilities2EXT");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
-            dump_string<Format>(settings, "VkDisplayPowerInfoEXT");
+            dump_value(api_dump, "VkDisplayPowerInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
-            dump_string<Format>(settings, "VkDeviceEventInfoEXT");
+            dump_value(api_dump, "VkDeviceEventInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
-            dump_string<Format>(settings, "VkDisplayEventInfoEXT");
+            dump_value(api_dump, "VkDisplayEventInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkSwapchainCounterCreateInfoEXT");
+            dump_value(api_dump, "VkSwapchainCounterCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
-            dump_string<Format>(settings, "VkPresentTimesInfoGOOGLE");
+            dump_value(api_dump, "VkPresentTimesInfoGOOGLE");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX");
+            dump_value(api_dump, "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX");
             break;
 
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
-            dump_string<Format>(settings, "VkMultiviewPerViewAttributesInfoNVX");
+            dump_value(api_dump, "VkMultiviewPerViewAttributesInfoNVX");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineViewportSwizzleStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineViewportSwizzleStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDiscardRectanglePropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDiscardRectanglePropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineDiscardRectangleStateCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineDiscardRectangleStateCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineRasterizationConservativeStateCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineRasterizationConservativeStateCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDepthClipEnableFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDepthClipEnableFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineRasterizationDepthClipStateCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineRasterizationDepthClipStateCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
-            dump_string<Format>(settings, "VkHdrMetadataEXT");
+            dump_value(api_dump, "VkHdrMetadataEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
-            dump_string<Format>(settings, "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG");
+            dump_value(api_dump, "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG");
             break;
 #if defined(VK_USE_PLATFORM_IOS_MVK)
 
         case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
-            dump_string<Format>(settings, "VkIOSSurfaceCreateInfoMVK");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "VkMacOSSurfaceCreateInfoMVK");
             break;
 #endif  // VK_USE_PLATFORM_MACOS_MVK
 
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
-            dump_string<Format>(settings, "VkDebugUtilsLabelEXT");
+            dump_value(api_dump, "VkDebugUtilsLabelEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugUtilsObjectNameInfoEXT");
+            dump_value(api_dump, "VkDebugUtilsObjectNameInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
-            dump_string<Format>(settings, "VkDebugUtilsMessengerCallbackDataEXT");
+            dump_value(api_dump, "VkDebugUtilsMessengerCallbackDataEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugUtilsMessengerCreateInfoEXT");
+            dump_value(api_dump, "VkDebugUtilsMessengerCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
-            dump_string<Format>(settings, "VkDebugUtilsObjectTagInfoEXT");
+            dump_value(api_dump, "VkDebugUtilsObjectTagInfoEXT");
             break;
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
 
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
-            dump_string<Format>(settings, "VkAndroidHardwareBufferUsageANDROID");
+            dump_value(api_dump, "VkAndroidHardwareBufferUsageANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
-            dump_string<Format>(settings, "VkAndroidHardwareBufferPropertiesANDROID");
+            dump_value(api_dump, "VkAndroidHardwareBufferPropertiesANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
-            dump_string<Format>(settings, "VkAndroidHardwareBufferFormatPropertiesANDROID");
+            dump_value(api_dump, "VkAndroidHardwareBufferFormatPropertiesANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
-            dump_string<Format>(settings, "VkImportAndroidHardwareBufferInfoANDROID");
+            dump_value(api_dump, "VkImportAndroidHardwareBufferInfoANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
-            dump_string<Format>(settings, "VkMemoryGetAndroidHardwareBufferInfoANDROID");
+            dump_value(api_dump, "VkMemoryGetAndroidHardwareBufferInfoANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
-            dump_string<Format>(settings, "VkExternalFormatANDROID");
+            dump_value(api_dump, "VkExternalFormatANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
-            dump_string<Format>(settings, "VkAndroidHardwareBufferFormatProperties2ANDROID");
+            dump_value(api_dump, "VkAndroidHardwareBufferFormatProperties2ANDROID");
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderEnqueueFeaturesAMDX");
+            dump_value(api_dump, "VkPhysicalDeviceShaderEnqueueFeaturesAMDX");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderEnqueuePropertiesAMDX");
+            dump_value(api_dump, "VkPhysicalDeviceShaderEnqueuePropertiesAMDX");
             break;
 
         case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX:
-            dump_string<Format>(settings, "VkExecutionGraphPipelineScratchSizeAMDX");
+            dump_value(api_dump, "VkExecutionGraphPipelineScratchSizeAMDX");
             break;
 
         case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
-            dump_string<Format>(settings, "VkExecutionGraphPipelineCreateInfoAMDX");
+            dump_value(api_dump, "VkExecutionGraphPipelineCreateInfoAMDX");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
-            dump_string<Format>(settings, "VkPipelineShaderStageNodeCreateInfoAMDX");
+            dump_value(api_dump, "VkPipelineShaderStageNodeCreateInfoAMDX");
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT:
-            dump_string<Format>(settings, "VkTexelBufferDescriptorInfoEXT");
+            dump_value(api_dump, "VkTexelBufferDescriptorInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT:
-            dump_string<Format>(settings, "VkImageDescriptorInfoEXT");
+            dump_value(api_dump, "VkImageDescriptorInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkTensorViewCreateInfoARM");
+            dump_value(api_dump, "VkTensorViewCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT:
-            dump_string<Format>(settings, "VkResourceDescriptorInfoEXT");
+            dump_value(api_dump, "VkResourceDescriptorInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT:
-            dump_string<Format>(settings, "VkBindHeapInfoEXT");
+            dump_value(api_dump, "VkBindHeapInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT:
-            dump_string<Format>(settings, "VkPushDataInfoEXT");
+            dump_value(api_dump, "VkPushDataInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT:
-            dump_string<Format>(settings, "VkDescriptorSetAndBindingMappingEXT");
+            dump_value(api_dump, "VkDescriptorSetAndBindingMappingEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT:
-            dump_string<Format>(settings, "VkShaderDescriptorSetAndBindingMappingInfoEXT");
+            dump_value(api_dump, "VkShaderDescriptorSetAndBindingMappingInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkOpaqueCaptureDataCreateInfoEXT");
+            dump_value(api_dump, "VkOpaqueCaptureDataCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorHeapFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorHeapFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorHeapPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorHeapPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT:
-            dump_string<Format>(settings, "VkCommandBufferInheritanceDescriptorHeapInfoEXT");
+            dump_value(api_dump, "VkCommandBufferInheritanceDescriptorHeapInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkSamplerCustomBorderColorIndexCreateInfoEXT");
+            dump_value(api_dump, "VkSamplerCustomBorderColorIndexCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkSamplerCustomBorderColorCreateInfoEXT");
+            dump_value(api_dump, "VkSamplerCustomBorderColorCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV:
-            dump_string<Format>(settings, "VkIndirectCommandsLayoutPushDataTokenNV");
+            dump_value(api_dump, "VkIndirectCommandsLayoutPushDataTokenNV");
             break;
 
         case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkSubsampledImageFormatPropertiesEXT");
+            dump_value(api_dump, "VkSubsampledImageFormatPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-            dump_string<Format>(settings, "VkAttachmentSampleCountInfoAMD");
+            dump_value(api_dump, "VkAttachmentSampleCountInfoAMD");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
-            dump_string<Format>(settings, "VkSampleLocationsInfoEXT");
+            dump_value(api_dump, "VkSampleLocationsInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
-            dump_string<Format>(settings, "VkRenderPassSampleLocationsBeginInfoEXT");
+            dump_value(api_dump, "VkRenderPassSampleLocationsBeginInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineSampleLocationsStateCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineSampleLocationsStateCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceSampleLocationsPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceSampleLocationsPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkMultisamplePropertiesEXT");
+            dump_value(api_dump, "VkMultisamplePropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineColorBlendAdvancedStateCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineColorBlendAdvancedStateCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineCoverageToColorStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineCoverageToColorStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineCoverageModulationStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineCoverageModulationStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-            dump_string<Format>(settings, "VkDrmFormatModifierPropertiesListEXT");
+            dump_value(api_dump, "VkDrmFormatModifierPropertiesListEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkImageDrmFormatModifierListCreateInfoEXT");
+            dump_value(api_dump, "VkImageDrmFormatModifierListCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkImageDrmFormatModifierExplicitCreateInfoEXT");
+            dump_value(api_dump, "VkImageDrmFormatModifierExplicitCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkImageDrmFormatModifierPropertiesEXT");
+            dump_value(api_dump, "VkImageDrmFormatModifierPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
-            dump_string<Format>(settings, "VkDrmFormatModifierPropertiesList2EXT");
+            dump_value(api_dump, "VkDrmFormatModifierPropertiesList2EXT");
             break;
 
         case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkValidationCacheCreateInfoEXT");
+            dump_value(api_dump, "VkValidationCacheCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkShaderModuleValidationCacheCreateInfoEXT");
+            dump_value(api_dump, "VkShaderModuleValidationCacheCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineViewportShadingRateImageStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineViewportShadingRateImageStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceShadingRateImageFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceShadingRateImageFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceShadingRateImagePropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceShadingRateImagePropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkRayTracingShaderGroupCreateInfoNV");
+            dump_value(api_dump, "VkRayTracingShaderGroupCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkRayTracingPipelineCreateInfoNV");
+            dump_value(api_dump, "VkRayTracingPipelineCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
-            dump_string<Format>(settings, "VkGeometryTrianglesNV");
+            dump_value(api_dump, "VkGeometryTrianglesNV");
             break;
 
         case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
-            dump_string<Format>(settings, "VkGeometryAABBNV");
+            dump_value(api_dump, "VkGeometryAABBNV");
             break;
 
         case VK_STRUCTURE_TYPE_GEOMETRY_NV:
-            dump_string<Format>(settings, "VkGeometryNV");
+            dump_value(api_dump, "VkGeometryNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureInfoNV");
+            dump_value(api_dump, "VkAccelerationStructureInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureCreateInfoNV");
+            dump_value(api_dump, "VkAccelerationStructureCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
-            dump_string<Format>(settings, "VkBindAccelerationStructureMemoryInfoNV");
+            dump_value(api_dump, "VkBindAccelerationStructureMemoryInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
-            dump_string<Format>(settings, "VkWriteDescriptorSetAccelerationStructureNV");
+            dump_value(api_dump, "VkWriteDescriptorSetAccelerationStructureNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureMemoryRequirementsInfoNV");
+            dump_value(api_dump, "VkAccelerationStructureMemoryRequirementsInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineRepresentativeFragmentTestStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineRepresentativeFragmentTestStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageViewImageFormatInfoEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImageViewImageFormatInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkFilterCubicImageViewImageFormatPropertiesEXT");
+            dump_value(api_dump, "VkFilterCubicImageViewImageFormatPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
-            dump_string<Format>(settings, "VkImportMemoryHostPointerInfoEXT");
+            dump_value(api_dump, "VkImportMemoryHostPointerInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkMemoryHostPointerPropertiesEXT");
+            dump_value(api_dump, "VkMemoryHostPointerPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
-            dump_string<Format>(settings, "VkPipelineCompilerControlCreateInfoAMD");
+            dump_value(api_dump, "VkPipelineCompilerControlCreateInfoAMD");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderCorePropertiesAMD");
+            dump_value(api_dump, "VkPhysicalDeviceShaderCorePropertiesAMD");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
-            dump_string<Format>(settings, "VkDeviceMemoryOverallocationCreateInfoAMD");
+            dump_value(api_dump, "VkDeviceMemoryOverallocationCreateInfoAMD");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT");
             break;
 #if defined(VK_USE_PLATFORM_GGP)
 
         case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
-            dump_string<Format>(settings, "VkPresentFrameTokenGGP");
+            dump_value(api_dump, "VkPresentFrameTokenGGP");
             break;
 #endif  // VK_USE_PLATFORM_GGP
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceMeshShaderFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceMeshShaderPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderImageFootprintFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceShaderImageFootprintFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineViewportExclusiveScissorStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineViewportExclusiveScissorStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceExclusiveScissorFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceExclusiveScissorFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkQueueFamilyCheckpointPropertiesNV");
+            dump_value(api_dump, "VkQueueFamilyCheckpointPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
-            dump_string<Format>(settings, "VkCheckpointDataNV");
+            dump_value(api_dump, "VkCheckpointDataNV");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
-            dump_string<Format>(settings, "VkQueueFamilyCheckpointProperties2NV");
+            dump_value(api_dump, "VkQueueFamilyCheckpointProperties2NV");
             break;
 
         case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
-            dump_string<Format>(settings, "VkCheckpointData2NV");
+            dump_value(api_dump, "VkCheckpointData2NV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentTimingFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePresentTimingFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT:
-            dump_string<Format>(settings, "VkPresentTimingSurfaceCapabilitiesEXT");
+            dump_value(api_dump, "VkPresentTimingSurfaceCapabilitiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT:
-            dump_string<Format>(settings, "VkSwapchainCalibratedTimestampInfoEXT");
+            dump_value(api_dump, "VkSwapchainCalibratedTimestampInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkSwapchainTimingPropertiesEXT");
+            dump_value(api_dump, "VkSwapchainTimingPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkSwapchainTimeDomainPropertiesEXT");
+            dump_value(api_dump, "VkSwapchainTimeDomainPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT:
-            dump_string<Format>(settings, "VkPastPresentationTimingInfoEXT");
+            dump_value(api_dump, "VkPastPresentationTimingInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT:
-            dump_string<Format>(settings, "VkPastPresentationTimingEXT");
+            dump_value(api_dump, "VkPastPresentationTimingEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPastPresentationTimingPropertiesEXT");
+            dump_value(api_dump, "VkPastPresentationTimingPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT:
-            dump_string<Format>(settings, "VkPresentTimingInfoEXT");
+            dump_value(api_dump, "VkPresentTimingInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT:
-            dump_string<Format>(settings, "VkPresentTimingsInfoEXT");
+            dump_value(api_dump, "VkPresentTimingsInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL");
+            dump_value(api_dump, "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
-            dump_string<Format>(settings, "VkInitializePerformanceApiInfoINTEL");
+            dump_value(api_dump, "VkInitializePerformanceApiInfoINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
-            dump_string<Format>(settings, "VkQueryPoolPerformanceQueryCreateInfoINTEL");
+            dump_value(api_dump, "VkQueryPoolPerformanceQueryCreateInfoINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
-            dump_string<Format>(settings, "VkPerformanceMarkerInfoINTEL");
+            dump_value(api_dump, "VkPerformanceMarkerInfoINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
-            dump_string<Format>(settings, "VkPerformanceStreamMarkerInfoINTEL");
+            dump_value(api_dump, "VkPerformanceStreamMarkerInfoINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
-            dump_string<Format>(settings, "VkPerformanceOverrideInfoINTEL");
+            dump_value(api_dump, "VkPerformanceOverrideInfoINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
-            dump_string<Format>(settings, "VkPerformanceConfigurationAcquireInfoINTEL");
+            dump_value(api_dump, "VkPerformanceConfigurationAcquireInfoINTEL");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePCIBusInfoPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePCIBusInfoPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
-            dump_string<Format>(settings, "VkDisplayNativeHdrSurfaceCapabilitiesAMD");
+            dump_value(api_dump, "VkDisplayNativeHdrSurfaceCapabilitiesAMD");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
-            dump_string<Format>(settings, "VkSwapchainDisplayNativeHdrCreateInfoAMD");
+            dump_value(api_dump, "VkSwapchainDisplayNativeHdrCreateInfoAMD");
             break;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
 
         case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkImagePipeSurfaceCreateInfoFUCHSIA");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "VkMetalSurfaceCreateInfoEXT");
             break;
 #endif  // VK_USE_PLATFORM_METAL_EXT
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkRenderPassFragmentDensityMapCreateInfoEXT");
+            dump_value(api_dump, "VkRenderPassFragmentDensityMapCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
-            dump_string<Format>(settings, "VkRenderingFragmentDensityMapAttachmentInfoEXT");
+            dump_value(api_dump, "VkRenderingFragmentDensityMapAttachmentInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderCoreProperties2AMD");
+            dump_value(api_dump, "VkPhysicalDeviceShaderCoreProperties2AMD");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
-            dump_string<Format>(settings, "VkPhysicalDeviceCoherentMemoryFeaturesAMD");
+            dump_value(api_dump, "VkPhysicalDeviceCoherentMemoryFeaturesAMD");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMemoryBudgetPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMemoryBudgetPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMemoryPriorityFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMemoryPriorityFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
-            dump_string<Format>(settings, "VkMemoryPriorityAllocateInfoEXT");
+            dump_value(api_dump, "VkMemoryPriorityAllocateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkBufferDeviceAddressCreateInfoEXT");
+            dump_value(api_dump, "VkBufferDeviceAddressCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
-            dump_string<Format>(settings, "VkValidationFeaturesEXT");
+            dump_value(api_dump, "VkValidationFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkCooperativeMatrixPropertiesNV");
+            dump_value(api_dump, "VkCooperativeMatrixPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrixFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrixPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCoverageReductionModeFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCoverageReductionModeFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineCoverageReductionStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineCoverageReductionStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
-            dump_string<Format>(settings, "VkFramebufferMixedSamplesCombinationNV");
+            dump_value(api_dump, "VkFramebufferMixedSamplesCombinationNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceProvokingVertexFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceProvokingVertexFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceProvokingVertexPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceProvokingVertexPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT");
             break;
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
 
         case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
-            dump_string<Format>(settings, "VkSurfaceFullScreenExclusiveInfoEXT");
+            dump_value(api_dump, "VkSurfaceFullScreenExclusiveInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
-            dump_string<Format>(settings, "VkSurfaceCapabilitiesFullScreenExclusiveEXT");
+            dump_value(api_dump, "VkSurfaceCapabilitiesFullScreenExclusiveEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
-            dump_string<Format>(settings, "VkSurfaceFullScreenExclusiveWin32InfoEXT");
+            dump_value(api_dump, "VkSurfaceFullScreenExclusiveWin32InfoEXT");
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
         case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkHeadlessSurfaceCreateInfoEXT");
+            dump_value(api_dump, "VkHeadlessSurfaceCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
-            dump_string<Format>(settings, "VkMemoryMapPlacedInfoEXT");
+            dump_value(api_dump, "VkMemoryMapPlacedInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkGraphicsShaderGroupCreateInfoNV");
+            dump_value(api_dump, "VkGraphicsShaderGroupCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkGraphicsPipelineShaderGroupsCreateInfoNV");
+            dump_value(api_dump, "VkGraphicsPipelineShaderGroupsCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
-            dump_string<Format>(settings, "VkIndirectCommandsLayoutTokenNV");
+            dump_value(api_dump, "VkIndirectCommandsLayoutTokenNV");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkIndirectCommandsLayoutCreateInfoNV");
+            dump_value(api_dump, "VkIndirectCommandsLayoutCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
-            dump_string<Format>(settings, "VkGeneratedCommandsInfoNV");
+            dump_value(api_dump, "VkGeneratedCommandsInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
-            dump_string<Format>(settings, "VkGeneratedCommandsMemoryRequirementsInfoNV");
+            dump_value(api_dump, "VkGeneratedCommandsMemoryRequirementsInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceInheritedViewportScissorFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceInheritedViewportScissorFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
-            dump_string<Format>(settings, "VkCommandBufferInheritanceViewportScissorInfoNV");
+            dump_value(api_dump, "VkCommandBufferInheritanceViewportScissorInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
-            dump_string<Format>(settings, "VkRenderPassTransformBeginInfoQCOM");
+            dump_value(api_dump, "VkRenderPassTransformBeginInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
-            dump_string<Format>(settings, "VkCommandBufferInheritanceRenderPassTransformInfoQCOM");
+            dump_value(api_dump, "VkCommandBufferInheritanceRenderPassTransformInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDepthBiasControlFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDepthBiasControlFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT:
-            dump_string<Format>(settings, "VkDepthBiasInfoEXT");
+            dump_value(api_dump, "VkDepthBiasInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
-            dump_string<Format>(settings, "VkDepthBiasRepresentationInfoEXT");
+            dump_value(api_dump, "VkDepthBiasRepresentationInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
-            dump_string<Format>(settings, "VkDeviceMemoryReportCallbackDataEXT");
+            dump_value(api_dump, "VkDeviceMemoryReportCallbackDataEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkDeviceDeviceMemoryReportCreateInfoEXT");
+            dump_value(api_dump, "VkDeviceDeviceMemoryReportCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceCustomBorderColorPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceCustomBorderColorPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceCustomBorderColorFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceCustomBorderColorFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentBarrierFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDevicePresentBarrierFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
-            dump_string<Format>(settings, "VkSurfaceCapabilitiesPresentBarrierNV");
+            dump_value(api_dump, "VkSurfaceCapabilitiesPresentBarrierNV");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkSwapchainPresentBarrierCreateInfoNV");
+            dump_value(api_dump, "VkSwapchainPresentBarrierCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDiagnosticsConfigFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDiagnosticsConfigFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkDeviceDiagnosticsConfigCreateInfoNV");
+            dump_value(api_dump, "VkDeviceDiagnosticsConfigCreateInfoNV");
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkCudaModuleCreateInfoNV");
+            dump_value(api_dump, "VkCudaModuleCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkCudaFunctionCreateInfoNV");
+            dump_value(api_dump, "VkCudaFunctionCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV:
-            dump_string<Format>(settings, "VkCudaLaunchInfoNV");
+            dump_value(api_dump, "VkCudaLaunchInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCudaKernelLaunchFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCudaKernelLaunchFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCudaKernelLaunchPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCudaKernelLaunchPropertiesNV");
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTileShadingFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceTileShadingFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTileShadingPropertiesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceTileShadingPropertiesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
-            dump_string<Format>(settings, "VkRenderPassTileShadingCreateInfoQCOM");
+            dump_value(api_dump, "VkRenderPassTileShadingCreateInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
-            dump_string<Format>(settings, "VkPerTileBeginInfoQCOM");
+            dump_value(api_dump, "VkPerTileBeginInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
-            dump_string<Format>(settings, "VkPerTileEndInfoQCOM");
+            dump_value(api_dump, "VkPerTileEndInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
-            dump_string<Format>(settings, "VkDispatchTileInfoQCOM");
+            dump_value(api_dump, "VkDispatchTileInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
-            dump_string<Format>(settings, "VkQueryLowLatencySupportNV");
+            dump_value(api_dump, "VkQueryLowLatencySupportNV");
             break;
 #if defined(VK_USE_PLATFORM_METAL_EXT)
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalObjectCreateInfoEXT");
+            dump_value(api_dump, "VkExportMetalObjectCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalObjectsInfoEXT");
+            dump_value(api_dump, "VkExportMetalObjectsInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalDeviceInfoEXT");
+            dump_value(api_dump, "VkExportMetalDeviceInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalCommandQueueInfoEXT");
+            dump_value(api_dump, "VkExportMetalCommandQueueInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalBufferInfoEXT");
+            dump_value(api_dump, "VkExportMetalBufferInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
-            dump_string<Format>(settings, "VkImportMetalBufferInfoEXT");
+            dump_value(api_dump, "VkImportMetalBufferInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalTextureInfoEXT");
+            dump_value(api_dump, "VkExportMetalTextureInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
-            dump_string<Format>(settings, "VkImportMetalTextureInfoEXT");
+            dump_value(api_dump, "VkImportMetalTextureInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalIOSurfaceInfoEXT");
+            dump_value(api_dump, "VkExportMetalIOSurfaceInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
-            dump_string<Format>(settings, "VkImportMetalIOSurfaceInfoEXT");
+            dump_value(api_dump, "VkImportMetalIOSurfaceInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
-            dump_string<Format>(settings, "VkExportMetalSharedEventInfoEXT");
+            dump_value(api_dump, "VkExportMetalSharedEventInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
-            dump_string<Format>(settings, "VkImportMetalSharedEventInfoEXT");
+            dump_value(api_dump, "VkImportMetalSharedEventInfoEXT");
             break;
 #endif  // VK_USE_PLATFORM_METAL_EXT
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorBufferPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorBufferFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT:
-            dump_string<Format>(settings, "VkDescriptorAddressInfoEXT");
+            dump_value(api_dump, "VkDescriptorAddressInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT:
-            dump_string<Format>(settings, "VkDescriptorBufferBindingInfoEXT");
+            dump_value(api_dump, "VkDescriptorBufferBindingInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
-            dump_string<Format>(settings, "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT");
+            dump_value(api_dump, "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT:
-            dump_string<Format>(settings, "VkDescriptorGetInfoEXT");
+            dump_value(api_dump, "VkDescriptorGetInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
-            dump_string<Format>(settings, "VkBufferCaptureDescriptorDataInfoEXT");
+            dump_value(api_dump, "VkBufferCaptureDescriptorDataInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
-            dump_string<Format>(settings, "VkImageCaptureDescriptorDataInfoEXT");
+            dump_value(api_dump, "VkImageCaptureDescriptorDataInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
-            dump_string<Format>(settings, "VkImageViewCaptureDescriptorDataInfoEXT");
+            dump_value(api_dump, "VkImageViewCaptureDescriptorDataInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
-            dump_string<Format>(settings, "VkSamplerCaptureDescriptorDataInfoEXT");
+            dump_value(api_dump, "VkSamplerCaptureDescriptorDataInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkOpaqueCaptureDescriptorDataCreateInfoEXT");
+            dump_value(api_dump, "VkOpaqueCaptureDescriptorDataCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
-            dump_string<Format>(settings, "VkAccelerationStructureCaptureDescriptorDataInfoEXT");
+            dump_value(api_dump, "VkAccelerationStructureCaptureDescriptorDataInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkGraphicsPipelineLibraryCreateInfoEXT");
+            dump_value(api_dump, "VkGraphicsPipelineLibraryCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD");
+            dump_value(api_dump, "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineFragmentShadingRateEnumStateCreateInfoNV");
+            dump_value(api_dump, "VkPipelineFragmentShadingRateEnumStateCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometryMotionTrianglesDataNV");
+            dump_value(api_dump, "VkAccelerationStructureGeometryMotionTrianglesDataNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureMotionInfoNV");
+            dump_value(api_dump, "VkAccelerationStructureMotionInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
-            dump_string<Format>(settings, "VkCopyCommandTransformInfoQCOM");
+            dump_value(api_dump, "VkCopyCommandTransformInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageCompressionControlFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImageCompressionControlFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
-            dump_string<Format>(settings, "VkImageCompressionControlEXT");
+            dump_value(api_dump, "VkImageCompressionControlEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkImageCompressionPropertiesEXT");
+            dump_value(api_dump, "VkImageCompressionPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevice4444FormatsFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevice4444FormatsFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFaultFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFaultFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT:
-            dump_string<Format>(settings, "VkDeviceFaultCountsEXT");
+            dump_value(api_dump, "VkDeviceFaultCountsEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT:
-            dump_string<Format>(settings, "VkDeviceFaultInfoEXT");
+            dump_value(api_dump, "VkDeviceFaultInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT");
             break;
 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
 
         case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkDirectFBSurfaceCreateInfoEXT");
+            dump_value(api_dump, "VkDirectFBSurfaceCreateInfoEXT");
             break;
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkMutableDescriptorTypeCreateInfoEXT");
+            dump_value(api_dump, "VkMutableDescriptorTypeCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
-            dump_string<Format>(settings, "VkVertexInputBindingDescription2EXT");
+            dump_value(api_dump, "VkVertexInputBindingDescription2EXT");
             break;
 
         case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
-            dump_string<Format>(settings, "VkVertexInputAttributeDescription2EXT");
+            dump_value(api_dump, "VkVertexInputAttributeDescription2EXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDrmPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDrmPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceAddressBindingReportFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceAddressBindingReportFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
-            dump_string<Format>(settings, "VkDeviceAddressBindingCallbackDataEXT");
+            dump_value(api_dump, "VkDeviceAddressBindingCallbackDataEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDepthClipControlFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDepthClipControlFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineViewportDepthClipControlCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineViewportDepthClipControlCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT");
             break;
 #if defined(VK_USE_PLATFORM_FUCHSIA)
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkImportMemoryZirconHandleInfoFUCHSIA");
+            dump_value(api_dump, "VkImportMemoryZirconHandleInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
-            dump_string<Format>(settings, "VkMemoryZirconHandlePropertiesFUCHSIA");
+            dump_value(api_dump, "VkMemoryZirconHandlePropertiesFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkMemoryGetZirconHandleInfoFUCHSIA");
+            dump_value(api_dump, "VkMemoryGetZirconHandleInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkImportSemaphoreZirconHandleInfoFUCHSIA");
+            dump_value(api_dump, "VkImportSemaphoreZirconHandleInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkSemaphoreGetZirconHandleInfoFUCHSIA");
+            dump_value(api_dump, "VkSemaphoreGetZirconHandleInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkBufferCollectionCreateInfoFUCHSIA");
+            dump_value(api_dump, "VkBufferCollectionCreateInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
-            dump_string<Format>(settings, "VkImportMemoryBufferCollectionFUCHSIA");
+            dump_value(api_dump, "VkImportMemoryBufferCollectionFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkBufferCollectionImageCreateInfoFUCHSIA");
+            dump_value(api_dump, "VkBufferCollectionImageCreateInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkBufferCollectionConstraintsInfoFUCHSIA");
+            dump_value(api_dump, "VkBufferCollectionConstraintsInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkBufferConstraintsInfoFUCHSIA");
+            dump_value(api_dump, "VkBufferConstraintsInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkBufferCollectionBufferCreateInfoFUCHSIA");
+            dump_value(api_dump, "VkBufferCollectionBufferCreateInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
-            dump_string<Format>(settings, "VkSysmemColorSpaceFUCHSIA");
+            dump_value(api_dump, "VkSysmemColorSpaceFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
-            dump_string<Format>(settings, "VkBufferCollectionPropertiesFUCHSIA");
+            dump_value(api_dump, "VkBufferCollectionPropertiesFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkImageFormatConstraintsInfoFUCHSIA");
+            dump_value(api_dump, "VkImageFormatConstraintsInfoFUCHSIA");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
-            dump_string<Format>(settings, "VkImageConstraintsInfoFUCHSIA");
+            dump_value(api_dump, "VkImageConstraintsInfoFUCHSIA");
             break;
 #endif  // VK_USE_PLATFORM_FUCHSIA
 
         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
-            dump_string<Format>(settings, "VkSubpassShadingPipelineCreateInfoHUAWEI");
+            dump_value(api_dump, "VkSubpassShadingPipelineCreateInfoHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
-            dump_string<Format>(settings, "VkMemoryGetRemoteAddressInfoNV");
+            dump_value(api_dump, "VkMemoryGetRemoteAddressInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
-            dump_string<Format>(settings, "VkPipelinePropertiesIdentifierEXT");
+            dump_value(api_dump, "VkPipelinePropertiesIdentifierEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelinePropertiesFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePipelinePropertiesFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFrameBoundaryFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFrameBoundaryFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
-            dump_string<Format>(settings, "VkFrameBoundaryEXT");
+            dump_value(api_dump, "VkFrameBoundaryEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
-            dump_string<Format>(settings, "VkSubpassResolvePerformanceQueryEXT");
+            dump_value(api_dump, "VkSubpassResolvePerformanceQueryEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
-            dump_string<Format>(settings, "VkMultisampledRenderToSingleSampledInfoEXT");
+            dump_value(api_dump, "VkMultisampledRenderToSingleSampledInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT");
             break;
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
 
         case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
-            dump_string<Format>(settings, "VkScreenSurfaceCreateInfoQNX");
+            dump_value(api_dump, "VkScreenSurfaceCreateInfoQNX");
             break;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceColorWriteEnableFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceColorWriteEnableFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineColorWriteCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineColorWriteCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
-            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE");
+            dump_value(api_dump, "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
-            dump_string<Format>(settings, "VkVideoEncodeRgbConversionCapabilitiesVALVE");
+            dump_value(api_dump, "VkVideoEncodeRgbConversionCapabilitiesVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
-            dump_string<Format>(settings, "VkVideoEncodeProfileRgbConversionInfoVALVE");
+            dump_value(api_dump, "VkVideoEncodeProfileRgbConversionInfoVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
-            dump_string<Format>(settings, "VkVideoEncodeSessionRgbConversionCreateInfoVALVE");
+            dump_value(api_dump, "VkVideoEncodeSessionRgbConversionCreateInfoVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageViewMinLodFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImageViewMinLodFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkImageViewMinLodCreateInfoEXT");
+            dump_value(api_dump, "VkImageViewMinLodCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiDrawFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMultiDrawFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiDrawPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMultiDrawPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderTileImageFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderTileImageFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderTileImagePropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderTileImagePropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT:
-            dump_string<Format>(settings, "VkMicromapBuildInfoEXT");
+            dump_value(api_dump, "VkMicromapBuildInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkMicromapCreateInfoEXT");
+            dump_value(api_dump, "VkMicromapCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceOpacityMicromapFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceOpacityMicromapFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceOpacityMicromapPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceOpacityMicromapPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT:
-            dump_string<Format>(settings, "VkMicromapVersionInfoEXT");
+            dump_value(api_dump, "VkMicromapVersionInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT:
-            dump_string<Format>(settings, "VkCopyMicromapToMemoryInfoEXT");
+            dump_value(api_dump, "VkCopyMicromapToMemoryInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT:
-            dump_string<Format>(settings, "VkCopyMemoryToMicromapInfoEXT");
+            dump_value(api_dump, "VkCopyMemoryToMicromapInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT:
-            dump_string<Format>(settings, "VkCopyMicromapInfoEXT");
+            dump_value(api_dump, "VkCopyMicromapInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT:
-            dump_string<Format>(settings, "VkMicromapBuildSizesInfoEXT");
+            dump_value(api_dump, "VkMicromapBuildSizesInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
-            dump_string<Format>(settings, "VkAccelerationStructureTrianglesOpacityMicromapEXT");
+            dump_value(api_dump, "VkAccelerationStructureTrianglesOpacityMicromapEXT");
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDisplacementMicromapFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDisplacementMicromapFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDisplacementMicromapPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDisplacementMicromapPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureTrianglesDisplacementMicromapNV");
+            dump_value(api_dump, "VkAccelerationStructureTrianglesDisplacementMicromapNV");
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkSamplerBorderColorComponentMappingCreateInfoEXT");
+            dump_value(api_dump, "VkSamplerBorderColorComponentMappingCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderCorePropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceShaderCorePropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDeviceQueueShaderCoreControlCreateInfoARM");
+            dump_value(api_dump, "VkDeviceQueueShaderCoreControlCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceSchedulingControlsFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceSchedulingControlsFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceSchedulingControlsPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceSchedulingControlsPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkImageViewSlicedCreateInfoEXT");
+            dump_value(api_dump, "VkImageViewSlicedCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
-            dump_string<Format>(settings, "VkDescriptorSetBindingReferenceVALVE");
+            dump_value(api_dump, "VkDescriptorSetBindingReferenceVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
-            dump_string<Format>(settings, "VkDescriptorSetLayoutHostMappingInfoVALVE");
+            dump_value(api_dump, "VkDescriptorSetLayoutHostMappingInfoVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceRenderPassStripedFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceRenderPassStripedFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceRenderPassStripedPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceRenderPassStripedPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM:
-            dump_string<Format>(settings, "VkRenderPassStripeInfoARM");
+            dump_value(api_dump, "VkRenderPassStripeInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
-            dump_string<Format>(settings, "VkRenderPassStripeBeginInfoARM");
+            dump_value(api_dump, "VkRenderPassStripeBeginInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
-            dump_string<Format>(settings, "VkRenderPassStripeSubmitInfoARM");
+            dump_value(api_dump, "VkRenderPassStripeSubmitInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
-            dump_string<Format>(settings, "VkRenderPassFragmentDensityMapOffsetEndInfoEXT");
+            dump_value(api_dump, "VkRenderPassFragmentDensityMapOffsetEndInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMemoryDecompressionFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMemoryDecompressionFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMemoryDecompressionPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMemoryDecompressionPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
-            dump_string<Format>(settings, "VkComputePipelineIndirectBufferInfoNV");
+            dump_value(api_dump, "VkComputePipelineIndirectBufferInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
-            dump_string<Format>(settings, "VkPipelineIndirectDeviceAddressInfoNV");
+            dump_value(api_dump, "VkPipelineIndirectDeviceAddressInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometryLinearSweptSpheresDataNV");
+            dump_value(api_dump, "VkAccelerationStructureGeometryLinearSweptSpheresDataNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometrySpheresDataNV");
+            dump_value(api_dump, "VkAccelerationStructureGeometrySpheresDataNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceLinearColorAttachmentFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceLinearColorAttachmentFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
-            dump_string<Format>(settings, "VkImageViewSampleWeightCreateInfoQCOM");
+            dump_value(api_dump, "VkImageViewSampleWeightCreateInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessingFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceImageProcessingFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessingPropertiesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceImageProcessingPropertiesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceNestedCommandBufferFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceNestedCommandBufferFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceNestedCommandBufferPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceNestedCommandBufferPropertiesEXT");
             break;
 #if defined(VK_USE_PLATFORM_OHOS)
 
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS:
-            dump_string<Format>(settings, "VkNativeBufferUsageOHOS");
+            dump_value(api_dump, "VkNativeBufferUsageOHOS");
             break;
 
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS:
-            dump_string<Format>(settings, "VkNativeBufferPropertiesOHOS");
+            dump_value(api_dump, "VkNativeBufferPropertiesOHOS");
             break;
 
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS:
-            dump_string<Format>(settings, "VkNativeBufferFormatPropertiesOHOS");
+            dump_value(api_dump, "VkNativeBufferFormatPropertiesOHOS");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS:
-            dump_string<Format>(settings, "VkImportNativeBufferInfoOHOS");
+            dump_value(api_dump, "VkImportNativeBufferInfoOHOS");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS:
-            dump_string<Format>(settings, "VkMemoryGetNativeBufferInfoOHOS");
+            dump_value(api_dump, "VkMemoryGetNativeBufferInfoOHOS");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS:
-            dump_string<Format>(settings, "VkExternalFormatOHOS");
+            dump_value(api_dump, "VkExternalFormatOHOS");
             break;
 #endif  // VK_USE_PLATFORM_OHOS
 
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
-            dump_string<Format>(settings, "VkExternalMemoryAcquireUnmodifiedEXT");
+            dump_value(api_dump, "VkExternalMemoryAcquireUnmodifiedEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
-            dump_string<Format>(settings, "VkRenderPassCreationControlEXT");
+            dump_value(api_dump, "VkRenderPassCreationControlEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkRenderPassCreationFeedbackCreateInfoEXT");
+            dump_value(api_dump, "VkRenderPassCreationFeedbackCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkRenderPassSubpassFeedbackCreateInfoEXT");
+            dump_value(api_dump, "VkRenderPassSubpassFeedbackCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG:
-            dump_string<Format>(settings, "VkDirectDriverLoadingInfoLUNARG");
+            dump_value(api_dump, "VkDirectDriverLoadingInfoLUNARG");
             break;
 
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
-            dump_string<Format>(settings, "VkDirectDriverLoadingListLUNARG");
+            dump_value(api_dump, "VkDirectDriverLoadingListLUNARG");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
-            dump_string<Format>(settings, "VkTensorDescriptionARM");
+            dump_value(api_dump, "VkTensorDescriptionARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkTensorCreateInfoARM");
+            dump_value(api_dump, "VkTensorCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM:
-            dump_string<Format>(settings, "VkTensorMemoryRequirementsInfoARM");
+            dump_value(api_dump, "VkTensorMemoryRequirementsInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM:
-            dump_string<Format>(settings, "VkBindTensorMemoryInfoARM");
+            dump_value(api_dump, "VkBindTensorMemoryInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
-            dump_string<Format>(settings, "VkWriteDescriptorSetTensorARM");
+            dump_value(api_dump, "VkWriteDescriptorSetTensorARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkTensorFormatPropertiesARM");
+            dump_value(api_dump, "VkTensorFormatPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTensorPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceTensorPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
-            dump_string<Format>(settings, "VkTensorMemoryBarrierARM");
+            dump_value(api_dump, "VkTensorMemoryBarrierARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
-            dump_string<Format>(settings, "VkTensorDependencyInfoARM");
+            dump_value(api_dump, "VkTensorDependencyInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTensorFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceTensorFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM:
-            dump_string<Format>(settings, "VkDeviceTensorMemoryRequirementsARM");
+            dump_value(api_dump, "VkDeviceTensorMemoryRequirementsARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM:
-            dump_string<Format>(settings, "VkTensorCopyARM");
+            dump_value(api_dump, "VkTensorCopyARM");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM:
-            dump_string<Format>(settings, "VkCopyTensorInfoARM");
+            dump_value(api_dump, "VkCopyTensorInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
-            dump_string<Format>(settings, "VkMemoryDedicatedAllocateInfoTensorARM");
+            dump_value(api_dump, "VkMemoryDedicatedAllocateInfoTensorARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalTensorInfoARM");
+            dump_value(api_dump, "VkPhysicalDeviceExternalTensorInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkExternalTensorPropertiesARM");
+            dump_value(api_dump, "VkExternalTensorPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkExternalMemoryTensorCreateInfoARM");
+            dump_value(api_dump, "VkExternalMemoryTensorCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
-            dump_string<Format>(settings, "VkDescriptorGetTensorInfoARM");
+            dump_value(api_dump, "VkDescriptorGetTensorInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
-            dump_string<Format>(settings, "VkTensorCaptureDescriptorDataInfoARM");
+            dump_value(api_dump, "VkTensorCaptureDescriptorDataInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
-            dump_string<Format>(settings, "VkTensorViewCaptureDescriptorDataInfoARM");
+            dump_value(api_dump, "VkTensorViewCaptureDescriptorDataInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
-            dump_string<Format>(settings, "VkFrameBoundaryTensorsARM");
+            dump_value(api_dump, "VkFrameBoundaryTensorsARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineShaderStageModuleIdentifierCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineShaderStageModuleIdentifierCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:
-            dump_string<Format>(settings, "VkShaderModuleIdentifierEXT");
+            dump_value(api_dump, "VkShaderModuleIdentifierEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceOpticalFlowFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceOpticalFlowFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceOpticalFlowPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceOpticalFlowPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
-            dump_string<Format>(settings, "VkOpticalFlowImageFormatInfoNV");
+            dump_value(api_dump, "VkOpticalFlowImageFormatInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkOpticalFlowImageFormatPropertiesNV");
+            dump_value(api_dump, "VkOpticalFlowImageFormatPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkOpticalFlowSessionCreateInfoNV");
+            dump_value(api_dump, "VkOpticalFlowSessionCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
-            dump_string<Format>(settings, "VkOpticalFlowSessionCreatePrivateDataInfoNV");
+            dump_value(api_dump, "VkOpticalFlowSessionCreatePrivateDataInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV:
-            dump_string<Format>(settings, "VkOpticalFlowExecuteInfoNV");
+            dump_value(api_dump, "VkOpticalFlowExecuteInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceLegacyDitheringFeaturesEXT");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID");
+            dump_value(api_dump, "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID");
             break;
 
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
-            dump_string<Format>(settings, "VkAndroidHardwareBufferFormatResolvePropertiesANDROID");
+            dump_value(api_dump, "VkAndroidHardwareBufferFormatResolvePropertiesANDROID");
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
-            dump_string<Format>(settings, "VkPhysicalDeviceAntiLagFeaturesAMD");
+            dump_value(api_dump, "VkPhysicalDeviceAntiLagFeaturesAMD");
             break;
 
         case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
-            dump_string<Format>(settings, "VkAntiLagPresentationInfoAMD");
+            dump_value(api_dump, "VkAntiLagPresentationInfoAMD");
             break;
 
         case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
-            dump_string<Format>(settings, "VkAntiLagDataAMD");
+            dump_value(api_dump, "VkAntiLagDataAMD");
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX:
-            dump_string<Format>(settings, "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX");
+            dump_value(api_dump, "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX:
-            dump_string<Format>(settings, "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX");
+            dump_value(api_dump, "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX");
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderObjectFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderObjectFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderObjectPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderObjectPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkShaderCreateInfoEXT");
+            dump_value(api_dump, "VkShaderCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTilePropertiesFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceTilePropertiesFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM:
-            dump_string<Format>(settings, "VkTilePropertiesQCOM");
+            dump_value(api_dump, "VkTilePropertiesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
-            dump_string<Format>(settings, "VkPhysicalDeviceAmigoProfilingFeaturesSEC");
+            dump_value(api_dump, "VkPhysicalDeviceAmigoProfilingFeaturesSEC");
             break;
 
         case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
-            dump_string<Format>(settings, "VkAmigoProfilingSubmitInfoSEC");
+            dump_value(api_dump, "VkAmigoProfilingSubmitInfoSEC");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeVectorPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeVectorPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeVectorFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeVectorFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkCooperativeVectorPropertiesNV");
+            dump_value(api_dump, "VkCooperativeVectorPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
-            dump_string<Format>(settings, "VkConvertCooperativeVectorMatrixInfoNV");
+            dump_value(api_dump, "VkConvertCooperativeVectorMatrixInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkLayerSettingsCreateInfoEXT");
+            dump_value(api_dump, "VkLayerSettingsCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV:
-            dump_string<Format>(settings, "VkLatencySleepModeInfoNV");
+            dump_value(api_dump, "VkLatencySleepModeInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV:
-            dump_string<Format>(settings, "VkLatencySleepInfoNV");
+            dump_value(api_dump, "VkLatencySleepInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV:
-            dump_string<Format>(settings, "VkSetLatencyMarkerInfoNV");
+            dump_value(api_dump, "VkSetLatencyMarkerInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV:
-            dump_string<Format>(settings, "VkLatencyTimingsFrameReportNV");
+            dump_value(api_dump, "VkLatencyTimingsFrameReportNV");
             break;
 
         case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV:
-            dump_string<Format>(settings, "VkGetLatencyMarkerInfoNV");
+            dump_value(api_dump, "VkGetLatencyMarkerInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
-            dump_string<Format>(settings, "VkLatencySubmissionPresentIdNV");
+            dump_value(api_dump, "VkLatencySubmissionPresentIdNV");
             break;
 
         case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkSwapchainLatencyCreateInfoNV");
+            dump_value(api_dump, "VkSwapchainLatencyCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV:
-            dump_string<Format>(settings, "VkOutOfBandQueueTypeInfoNV");
+            dump_value(api_dump, "VkOutOfBandQueueTypeInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
-            dump_string<Format>(settings, "VkLatencySurfaceCapabilitiesNV");
+            dump_value(api_dump, "VkLatencySurfaceCapabilitiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceDataGraphFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceDataGraphFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineConstantARM");
+            dump_value(api_dump, "VkDataGraphPipelineConstantARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineResourceInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineResourceInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineCompilerControlCreateInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineCompilerControlCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineCreateInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineShaderModuleCreateInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineShaderModuleCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineSessionCreateInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineSessionCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineSessionBindPointRequirementsInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineSessionBindPointRequirementsInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineSessionBindPointRequirementARM");
+            dump_value(api_dump, "VkDataGraphPipelineSessionBindPointRequirementARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineSessionMemoryRequirementsInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineSessionMemoryRequirementsInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM:
-            dump_string<Format>(settings, "VkBindDataGraphPipelineSessionMemoryInfoARM");
+            dump_value(api_dump, "VkBindDataGraphPipelineSessionMemoryInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelinePropertyQueryResultARM");
+            dump_value(api_dump, "VkDataGraphPipelinePropertyQueryResultARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineIdentifierCreateInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineIdentifierCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineDispatchInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineDispatchInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkQueueFamilyDataGraphPropertiesARM");
+            dump_value(api_dump, "VkQueueFamilyDataGraphPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphProcessingEngineCreateInfoARM");
+            dump_value(api_dump, "VkDataGraphProcessingEngineCreateInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM");
+            dump_value(api_dump, "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM");
+            dump_value(api_dump, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
-            dump_string<Format>(settings, "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM");
+            dump_value(api_dump, "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
-            dump_string<Format>(settings, "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM");
+            dump_value(api_dump, "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessing2FeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceImageProcessing2FeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessing2PropertiesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceImageProcessing2PropertiesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
-            dump_string<Format>(settings, "VkSamplerBlockMatchWindowCreateInfoQCOM");
+            dump_value(api_dump, "VkSamplerBlockMatchWindowCreateInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceCubicWeightsFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceCubicWeightsFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
-            dump_string<Format>(settings, "VkSamplerCubicWeightsCreateInfoQCOM");
+            dump_value(api_dump, "VkSamplerCubicWeightsCreateInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
-            dump_string<Format>(settings, "VkBlitImageCubicWeightsInfoQCOM");
+            dump_value(api_dump, "VkBlitImageCubicWeightsInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
-            dump_string<Format>(settings, "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM");
+            dump_value(api_dump, "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceCubicClampFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceCubicClampFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT");
             break;
 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
 
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
-            dump_string<Format>(settings, "VkScreenBufferPropertiesQNX");
+            dump_value(api_dump, "VkScreenBufferPropertiesQNX");
             break;
 
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
-            dump_string<Format>(settings, "VkScreenBufferFormatPropertiesQNX");
+            dump_value(api_dump, "VkScreenBufferFormatPropertiesQNX");
             break;
 
         case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
-            dump_string<Format>(settings, "VkImportScreenBufferInfoQNX");
+            dump_value(api_dump, "VkImportScreenBufferInfoQNX");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
-            dump_string<Format>(settings, "VkExternalFormatQNX");
+            dump_value(api_dump, "VkExternalFormatQNX");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX");
+            dump_value(api_dump, "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX");
             break;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
-            dump_string<Format>(settings, "VkPhysicalDeviceLayeredDriverPropertiesMSFT");
+            dump_value(api_dump, "VkPhysicalDeviceLayeredDriverPropertiesMSFT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
-            dump_string<Format>(settings, "VkTileMemoryRequirementsQCOM");
+            dump_value(api_dump, "VkTileMemoryRequirementsQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
-            dump_string<Format>(settings, "VkTileMemoryBindInfoQCOM");
+            dump_value(api_dump, "VkTileMemoryBindInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
-            dump_string<Format>(settings, "VkTileMemorySizeInfoQCOM");
+            dump_value(api_dump, "VkTileMemorySizeInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT:
-            dump_string<Format>(settings, "VkDecompressMemoryInfoEXT");
+            dump_value(api_dump, "VkDecompressMemoryInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkDisplaySurfaceStereoCreateInfoNV");
+            dump_value(api_dump, "VkDisplaySurfaceStereoCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkDisplayModeStereoPropertiesNV");
+            dump_value(api_dump, "VkDisplayModeStereoPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRawAccessChainsFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRawAccessChainsFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkExternalComputeQueueDeviceCreateInfoNV");
+            dump_value(api_dump, "VkExternalComputeQueueDeviceCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkExternalComputeQueueCreateInfoNV");
+            dump_value(api_dump, "VkExternalComputeQueueCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
-            dump_string<Format>(settings, "VkExternalComputeQueueDataParamsNV");
+            dump_value(api_dump, "VkExternalComputeQueueDataParamsNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceExternalComputeQueuePropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceExternalComputeQueuePropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderFloat8FeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderFloat8FeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingValidationFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingValidationFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
-            dump_string<Format>(settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV");
+            dump_value(api_dump, "VkClusterAccelerationStructureClustersBottomLevelInputNV");
             break;
 
         case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
-            dump_string<Format>(settings, "VkClusterAccelerationStructureTriangleClusterInputNV");
+            dump_value(api_dump, "VkClusterAccelerationStructureTriangleClusterInputNV");
             break;
 
         case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
-            dump_string<Format>(settings, "VkClusterAccelerationStructureMoveObjectsInputNV");
+            dump_value(api_dump, "VkClusterAccelerationStructureMoveObjectsInputNV");
             break;
 
         case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
-            dump_string<Format>(settings, "VkClusterAccelerationStructureInputInfoNV");
+            dump_value(api_dump, "VkClusterAccelerationStructureInputInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
-            dump_string<Format>(settings, "VkClusterAccelerationStructureCommandsInfoNV");
+            dump_value(api_dump, "VkClusterAccelerationStructureCommandsInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureBuildSizesInfoKHR");
+            dump_value(api_dump, "VkAccelerationStructureBuildSizesInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
-            dump_string<Format>(settings, "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV");
+            dump_value(api_dump, "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV");
+            dump_value(api_dump, "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
-            dump_string<Format>(settings, "VkPartitionedAccelerationStructureFlagsNV");
+            dump_value(api_dump, "VkPartitionedAccelerationStructureFlagsNV");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
-            dump_string<Format>(settings, "VkWriteDescriptorSetPartitionedAccelerationStructureNV");
+            dump_value(api_dump, "VkWriteDescriptorSetPartitionedAccelerationStructureNV");
             break;
 
         case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
-            dump_string<Format>(settings, "VkPartitionedAccelerationStructureInstancesInputNV");
+            dump_value(api_dump, "VkPartitionedAccelerationStructureInstancesInputNV");
             break;
 
         case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
-            dump_string<Format>(settings, "VkBuildPartitionedAccelerationStructureInfoNV");
+            dump_value(api_dump, "VkBuildPartitionedAccelerationStructureInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT:
-            dump_string<Format>(settings, "VkGeneratedCommandsMemoryRequirementsInfoEXT");
+            dump_value(api_dump, "VkGeneratedCommandsMemoryRequirementsInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT:
-            dump_string<Format>(settings, "VkIndirectExecutionSetPipelineInfoEXT");
+            dump_value(api_dump, "VkIndirectExecutionSetPipelineInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT:
-            dump_string<Format>(settings, "VkIndirectExecutionSetShaderLayoutInfoEXT");
+            dump_value(api_dump, "VkIndirectExecutionSetShaderLayoutInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT:
-            dump_string<Format>(settings, "VkIndirectExecutionSetShaderInfoEXT");
+            dump_value(api_dump, "VkIndirectExecutionSetShaderInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkIndirectExecutionSetCreateInfoEXT");
+            dump_value(api_dump, "VkIndirectExecutionSetCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT:
-            dump_string<Format>(settings, "VkGeneratedCommandsInfoEXT");
+            dump_value(api_dump, "VkGeneratedCommandsInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT:
-            dump_string<Format>(settings, "VkWriteIndirectExecutionSetPipelineEXT");
+            dump_value(api_dump, "VkWriteIndirectExecutionSetPipelineEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT:
-            dump_string<Format>(settings, "VkIndirectCommandsLayoutTokenEXT");
+            dump_value(api_dump, "VkIndirectCommandsLayoutTokenEXT");
             break;
 
         case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkIndirectCommandsLayoutCreateInfoEXT");
+            dump_value(api_dump, "VkIndirectCommandsLayoutCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
-            dump_string<Format>(settings, "VkGeneratedCommandsPipelineInfoEXT");
+            dump_value(api_dump, "VkGeneratedCommandsPipelineInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
-            dump_string<Format>(settings, "VkGeneratedCommandsShaderInfoEXT");
+            dump_value(api_dump, "VkGeneratedCommandsShaderInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT:
-            dump_string<Format>(settings, "VkWriteIndirectExecutionSetShaderEXT");
+            dump_value(api_dump, "VkWriteIndirectExecutionSetShaderEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageAlignmentControlFeaturesMESA");
+            dump_value(api_dump, "VkPhysicalDeviceImageAlignmentControlFeaturesMESA");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
-            dump_string<Format>(settings, "VkPhysicalDeviceImageAlignmentControlPropertiesMESA");
+            dump_value(api_dump, "VkPhysicalDeviceImageAlignmentControlPropertiesMESA");
             break;
 
         case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
-            dump_string<Format>(settings, "VkImageAlignmentControlCreateInfoMESA");
+            dump_value(api_dump, "VkImageAlignmentControlCreateInfoMESA");
             break;
 
         case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV:
-            dump_string<Format>(settings, "VkPushConstantBankInfoNV");
+            dump_value(api_dump, "VkPushConstantBankInfoNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePushConstantBankFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDevicePushConstantBankFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePushConstantBankPropertiesNV");
+            dump_value(api_dump, "VkPhysicalDevicePushConstantBankPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceDepthClampControlFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceDepthClampControlFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkPipelineViewportDepthClampControlCreateInfoEXT");
+            dump_value(api_dump, "VkPipelineViewportDepthClampControlCreateInfoEXT");
             break;
 #if defined(VK_USE_PLATFORM_OHOS)
 
         case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS:
-            dump_string<Format>(settings, "VkSurfaceCreateInfoOHOS");
+            dump_value(api_dump, "VkSurfaceCreateInfoOHOS");
             break;
 #endif  // VK_USE_PLATFORM_OHOS
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
-            dump_string<Format>(settings, "VkPhysicalDeviceHdrVividFeaturesHUAWEI");
+            dump_value(api_dump, "VkPhysicalDeviceHdrVividFeaturesHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
-            dump_string<Format>(settings, "VkHdrVividDynamicMetadataHUAWEI");
+            dump_value(api_dump, "VkHdrVividDynamicMetadataHUAWEI");
             break;
 
         case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV");
+            dump_value(api_dump, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrix2FeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrix2FeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrix2PropertiesNV");
+            dump_value(api_dump, "VkPhysicalDeviceCooperativeMatrix2PropertiesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM");
             break;
 #if defined(VK_USE_PLATFORM_METAL_EXT)
 
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
-            dump_string<Format>(settings, "VkImportMemoryMetalHandleInfoEXT");
+            dump_value(api_dump, "VkImportMemoryMetalHandleInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkMemoryMetalHandlePropertiesEXT");
+            dump_value(api_dump, "VkMemoryMetalHandlePropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT:
-            dump_string<Format>(settings, "VkMemoryGetMetalHandleInfoEXT");
+            dump_value(api_dump, "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");
+            dump_value(api_dump, "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM");
+            dump_value(api_dump, "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM:
-            dump_string<Format>(settings, "VkPerformanceCounterARM");
+            dump_value(api_dump, "VkPerformanceCounterARM");
             break;
 
         case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM:
-            dump_string<Format>(settings, "VkPerformanceCounterDescriptionARM");
+            dump_value(api_dump, "VkPerformanceCounterDescriptionARM");
             break;
 
         case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM:
-            dump_string<Format>(settings, "VkRenderPassPerformanceCountersByRegionBeginInfoARM");
+            dump_value(api_dump, "VkRenderPassPerformanceCountersByRegionBeginInfoARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
-            dump_string<Format>(settings, "VkPhysicalDeviceFormatPackFeaturesARM");
+            dump_value(api_dump, "VkPhysicalDeviceFormatPackFeaturesARM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
-            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE");
+            dump_value(api_dump, "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE");
             break;
 
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
-            dump_string<Format>(settings, "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE");
+            dump_value(api_dump, "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE");
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
-            dump_string<Format>(settings, "VkSetPresentConfigNV");
+            dump_value(api_dump, "VkSetPresentConfigNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDevicePresentMeteringFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDevicePresentMeteringFeaturesNV");
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShader64BitIndexingFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShader64BitIndexingFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceCustomResolveFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceCustomResolveFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT:
-            dump_string<Format>(settings, "VkBeginCustomResolveInfoEXT");
+            dump_value(api_dump, "VkBeginCustomResolveInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT:
-            dump_string<Format>(settings, "VkCustomResolveCreateInfoEXT");
+            dump_value(api_dump, "VkCustomResolveCreateInfoEXT");
             break;
 
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM:
-            dump_string<Format>(settings, "VkDataGraphPipelineBuiltinModelCreateInfoQCOM");
+            dump_value(api_dump, "VkDataGraphPipelineBuiltinModelCreateInfoQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM:
-            dump_string<Format>(settings, "VkPhysicalDeviceDataGraphModelFeaturesQCOM");
+            dump_value(api_dump, "VkPhysicalDeviceDataGraphModelFeaturesQCOM");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderLongVectorFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderLongVectorFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderLongVectorPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderLongVectorPropertiesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
-            dump_string<Format>(settings, "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC");
+            dump_value(api_dump, "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV:
-            dump_string<Format>(settings, "VkComputeOccupancyPriorityParametersNV");
+            dump_value(api_dump, "VkComputeOccupancyPriorityParametersNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV:
-            dump_string<Format>(settings, "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV");
+            dump_value(api_dump, "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometryTrianglesDataKHR");
+            dump_value(api_dump, "VkAccelerationStructureGeometryTrianglesDataKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometryAabbsDataKHR");
+            dump_value(api_dump, "VkAccelerationStructureGeometryAabbsDataKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometryInstancesDataKHR");
+            dump_value(api_dump, "VkAccelerationStructureGeometryInstancesDataKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureGeometryKHR");
+            dump_value(api_dump, "VkAccelerationStructureGeometryKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureBuildGeometryInfoKHR");
+            dump_value(api_dump, "VkAccelerationStructureBuildGeometryInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureCreateInfoKHR");
+            dump_value(api_dump, "VkAccelerationStructureCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
-            dump_string<Format>(settings, "VkWriteDescriptorSetAccelerationStructureKHR");
+            dump_value(api_dump, "VkWriteDescriptorSetAccelerationStructureKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceAccelerationStructureFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceAccelerationStructureFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceAccelerationStructurePropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceAccelerationStructurePropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureDeviceAddressInfoKHR");
+            dump_value(api_dump, "VkAccelerationStructureDeviceAddressInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
-            dump_string<Format>(settings, "VkAccelerationStructureVersionInfoKHR");
+            dump_value(api_dump, "VkAccelerationStructureVersionInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
-            dump_string<Format>(settings, "VkCopyAccelerationStructureToMemoryInfoKHR");
+            dump_value(api_dump, "VkCopyAccelerationStructureToMemoryInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkCopyMemoryToAccelerationStructureInfoKHR");
+            dump_value(api_dump, "VkCopyMemoryToAccelerationStructureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
-            dump_string<Format>(settings, "VkCopyAccelerationStructureInfoKHR");
+            dump_value(api_dump, "VkCopyAccelerationStructureInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkRayTracingShaderGroupCreateInfoKHR");
+            dump_value(api_dump, "VkRayTracingShaderGroupCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkRayTracingPipelineInterfaceCreateInfoKHR");
+            dump_value(api_dump, "VkRayTracingPipelineInterfaceCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
-            dump_string<Format>(settings, "VkRayTracingPipelineCreateInfoKHR");
+            dump_value(api_dump, "VkRayTracingPipelineCreateInfoKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPipelineFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingPipelineFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPipelinePropertiesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRayTracingPipelinePropertiesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
-            dump_string<Format>(settings, "VkPhysicalDeviceRayQueryFeaturesKHR");
+            dump_value(api_dump, "VkPhysicalDeviceRayQueryFeaturesKHR");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderFeaturesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMeshShaderFeaturesEXT");
             break;
 
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
-            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderPropertiesEXT");
+            dump_value(api_dump, "VkPhysicalDeviceMeshShaderPropertiesEXT");
             break;
 
         default:
-            dump_string<Format>(settings, "NULL");
+            dump_value(api_dump, "NULL");
             break;
     }
-    dump_end<Format>(settings, OutputConstruct::value, indents);
+    dump_end(api_dump, 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) {
+void dump_pNext_trampoline(ApiDumpInstance& api_dump, const void* object, 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);
+        if (api_dump.settings().format() == ApiDumpFormat::Html || api_dump.settings().format() == ApiDumpFormat::Json) {
+            dump_nullptr(api_dump, type_name, var_name, indents);
         }
         return;
     }
@@ -47867,17089 +45776,15526 @@ void dump_pNext_trampoline(const void* object, const ApiDumpSettings& settings,
     memcpy(&base_struct, object, sizeof(VkBaseInStructure));
     switch (base_struct.sType) {
         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));
+            dump_VkBufferMemoryBarrier(api_dump, *reinterpret_cast<const VkBufferMemoryBarrier*>(object), (api_dump.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));
+            dump_VkImageMemoryBarrier(api_dump, *reinterpret_cast<const VkImageMemoryBarrier*>(object), (api_dump.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));
+            dump_VkMemoryBarrier(api_dump, *reinterpret_cast<const VkMemoryBarrier*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkMemoryBarrier*" : "VkMemoryBarrier"), "pNext", indents, reinterpret_cast<const VkMemoryBarrier*>(object));
             break;
 
         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));
+            dump_VkApplicationInfo(api_dump, *reinterpret_cast<const VkApplicationInfo*>(object), (api_dump.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));
+            dump_VkInstanceCreateInfo(api_dump, *reinterpret_cast<const VkInstanceCreateInfo*>(object), (api_dump.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));
+            dump_VkDeviceQueueCreateInfo(api_dump, *reinterpret_cast<const VkDeviceQueueCreateInfo*>(object), (api_dump.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));
+            dump_VkDeviceCreateInfo(api_dump, *reinterpret_cast<const VkDeviceCreateInfo*>(object), (api_dump.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));
+            dump_VkSubmitInfo(api_dump, *reinterpret_cast<const VkSubmitInfo*>(object), (api_dump.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));
+            dump_VkMappedMemoryRange(api_dump, *reinterpret_cast<const VkMappedMemoryRange*>(object), (api_dump.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));
+            dump_VkMemoryAllocateInfo(api_dump, *reinterpret_cast<const VkMemoryAllocateInfo*>(object), (api_dump.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));
+            dump_VkBindSparseInfo(api_dump, *reinterpret_cast<const VkBindSparseInfo*>(object), (api_dump.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));
+            dump_VkFenceCreateInfo(api_dump, *reinterpret_cast<const VkFenceCreateInfo*>(object), (api_dump.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));
+            dump_VkSemaphoreCreateInfo(api_dump, *reinterpret_cast<const VkSemaphoreCreateInfo*>(object), (api_dump.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));
+            dump_VkQueryPoolCreateInfo(api_dump, *reinterpret_cast<const VkQueryPoolCreateInfo*>(object), (api_dump.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));
+            dump_VkBufferCreateInfo(api_dump, *reinterpret_cast<const VkBufferCreateInfo*>(object), (api_dump.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));
+            dump_VkImageCreateInfo(api_dump, *reinterpret_cast<const VkImageCreateInfo*>(object), (api_dump.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));
+            dump_VkImageViewCreateInfo(api_dump, *reinterpret_cast<const VkImageViewCreateInfo*>(object), (api_dump.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));
+            dump_VkCommandPoolCreateInfo(api_dump, *reinterpret_cast<const VkCommandPoolCreateInfo*>(object), (api_dump.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));
+            dump_VkCommandBufferAllocateInfo(api_dump, *reinterpret_cast<const VkCommandBufferAllocateInfo*>(object), (api_dump.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));
+            dump_VkCommandBufferInheritanceInfo(api_dump, *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(object), (api_dump.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));
+            dump_VkCommandBufferBeginInfo(api_dump, *reinterpret_cast<const VkCommandBufferBeginInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkCommandBufferBeginInfo*" : "VkCommandBufferBeginInfo"), "pNext", indents, reinterpret_cast<const VkCommandBufferBeginInfo*>(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));
+            dump_VkEventCreateInfo(api_dump, *reinterpret_cast<const VkEventCreateInfo*>(object), (api_dump.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));
+            dump_VkBufferViewCreateInfo(api_dump, *reinterpret_cast<const VkBufferViewCreateInfo*>(object), (api_dump.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));
+            dump_VkShaderModuleCreateInfo(api_dump, *reinterpret_cast<const VkShaderModuleCreateInfo*>(object), (api_dump.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));
+            dump_VkPipelineCacheCreateInfo(api_dump, *reinterpret_cast<const VkPipelineCacheCreateInfo*>(object), (api_dump.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));
+            dump_VkPipelineShaderStageCreateInfo(api_dump, *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(object), (api_dump.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));
+            dump_VkComputePipelineCreateInfo(api_dump, *reinterpret_cast<const VkComputePipelineCreateInfo*>(object), (api_dump.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));
+            dump_VkPipelineLayoutCreateInfo(api_dump, *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(object), (api_dump.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));
+            dump_VkSamplerCreateInfo(api_dump, *reinterpret_cast<const VkSamplerCreateInfo*>(object), (api_dump.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));
+            dump_VkCopyDescriptorSet(api_dump, *reinterpret_cast<const VkCopyDescriptorSet*>(object), (api_dump.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));
+            dump_VkDescriptorPoolCreateInfo(api_dump, *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(object), (api_dump.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));
+            dump_VkDescriptorSetAllocateInfo(api_dump, *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(object), (api_dump.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));
+            dump_VkDescriptorSetLayoutCreateInfo(api_dump, *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(object), (api_dump.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));
+            dump_VkWriteDescriptorSet(api_dump, *reinterpret_cast<const VkWriteDescriptorSet*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkWriteDescriptorSet*" : "VkWriteDescriptorSet"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSet*>(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));
+            dump_VkPipelineVertexInputStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineVertexInputStateCreateInfo*" : "VkPipelineVertexInputStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(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));
+            dump_VkPipelineInputAssemblyStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineInputAssemblyStateCreateInfo*" : "VkPipelineInputAssemblyStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(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));
+            dump_VkPipelineTessellationStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineTessellationStateCreateInfo*" : "VkPipelineTessellationStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(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));
+            dump_VkPipelineViewportStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineViewportStateCreateInfo*" : "VkPipelineViewportStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(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));
+            dump_VkPipelineRasterizationStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineRasterizationStateCreateInfo*" : "VkPipelineRasterizationStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(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));
+            dump_VkPipelineMultisampleStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineMultisampleStateCreateInfo*" : "VkPipelineMultisampleStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(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));
+            dump_VkPipelineDepthStencilStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineDepthStencilStateCreateInfo*" : "VkPipelineDepthStencilStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(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));
+            dump_VkPipelineColorBlendStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineColorBlendStateCreateInfo*" : "VkPipelineColorBlendStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(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));
+            dump_VkPipelineDynamicStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineDynamicStateCreateInfo*" : "VkPipelineDynamicStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(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));
+            dump_VkGraphicsPipelineCreateInfo(api_dump, *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(object), (api_dump.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));
+            dump_VkFramebufferCreateInfo(api_dump, *reinterpret_cast<const VkFramebufferCreateInfo*>(object), (api_dump.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));
+            dump_VkRenderPassCreateInfo(api_dump, *reinterpret_cast<const VkRenderPassCreateInfo*>(object), (api_dump.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));
+            dump_VkRenderPassBeginInfo(api_dump, *reinterpret_cast<const VkRenderPassBeginInfo*>(object), (api_dump.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));
+            dump_VkBindBufferMemoryInfo(api_dump, *reinterpret_cast<const VkBindBufferMemoryInfo*>(object), (api_dump.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));
+            dump_VkBindImageMemoryInfo(api_dump, *reinterpret_cast<const VkBindImageMemoryInfo*>(object), (api_dump.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));
+            dump_VkMemoryDedicatedRequirements(api_dump, *reinterpret_cast<const VkMemoryDedicatedRequirements*>(object), (api_dump.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));
+            dump_VkMemoryDedicatedAllocateInfo(api_dump, *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(object), (api_dump.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));
+            dump_VkMemoryAllocateFlagsInfo(api_dump, *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(object), (api_dump.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));
+            dump_VkDeviceGroupCommandBufferBeginInfo(api_dump, *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(object), (api_dump.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));
+            dump_VkDeviceGroupSubmitInfo(api_dump, *reinterpret_cast<const VkDeviceGroupSubmitInfo*>(object), (api_dump.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));
+            dump_VkDeviceGroupBindSparseInfo(api_dump, *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(object), (api_dump.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));
+            dump_VkBindBufferMemoryDeviceGroupInfo(api_dump, *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(object), (api_dump.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));
+            dump_VkBindImageMemoryDeviceGroupInfo(api_dump, *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceGroupProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(object), (api_dump.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));
+            dump_VkDeviceGroupDeviceCreateInfo(api_dump, *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(object), (api_dump.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));
+            dump_VkBufferMemoryRequirementsInfo2(api_dump, *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(object), (api_dump.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));
+            dump_VkImageMemoryRequirementsInfo2(api_dump, *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(object), (api_dump.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));
+            dump_VkImageSparseMemoryRequirementsInfo2(api_dump, *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(object), (api_dump.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));
+            dump_VkMemoryRequirements2(api_dump, *reinterpret_cast<const VkMemoryRequirements2*>(object), (api_dump.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));
+            dump_VkSparseImageMemoryRequirements2(api_dump, *reinterpret_cast<const VkSparseImageMemoryRequirements2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFeatures2(api_dump, *reinterpret_cast<const VkPhysicalDeviceFeatures2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceProperties2(api_dump, *reinterpret_cast<const VkPhysicalDeviceProperties2*>(object), (api_dump.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));
+            dump_VkFormatProperties2(api_dump, *reinterpret_cast<const VkFormatProperties2*>(object), (api_dump.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));
+            dump_VkImageFormatProperties2(api_dump, *reinterpret_cast<const VkImageFormatProperties2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageFormatInfo2(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(object), (api_dump.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));
+            dump_VkQueueFamilyProperties2(api_dump, *reinterpret_cast<const VkQueueFamilyProperties2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMemoryProperties2(api_dump, *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(object), (api_dump.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));
+            dump_VkSparseImageFormatProperties2(api_dump, *reinterpret_cast<const VkSparseImageFormatProperties2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSparseImageFormatInfo2(api_dump, *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(object), (api_dump.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));
+            dump_VkImageViewUsageCreateInfo(api_dump, *reinterpret_cast<const VkImageViewUsageCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceProtectedMemoryFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceProtectedMemoryProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(object), (api_dump.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));
+            dump_VkDeviceQueueInfo2(api_dump, *reinterpret_cast<const VkDeviceQueueInfo2*>(object), (api_dump.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));
+            dump_VkProtectedSubmitInfo(api_dump, *reinterpret_cast<const VkProtectedSubmitInfo*>(object), (api_dump.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));
+            dump_VkBindImagePlaneMemoryInfo(api_dump, *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(object), (api_dump.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));
+            dump_VkImagePlaneMemoryRequirementsInfo(api_dump, *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalImageFormatInfo(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(object), (api_dump.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));
+            dump_VkExternalImageFormatProperties(api_dump, *reinterpret_cast<const VkExternalImageFormatProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalBufferInfo(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(object), (api_dump.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));
+            dump_VkExternalBufferProperties(api_dump, *reinterpret_cast<const VkExternalBufferProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceIDProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceIDProperties*>(object), (api_dump.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));
+            dump_VkExternalMemoryImageCreateInfo(api_dump, *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(object), (api_dump.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));
+            dump_VkExternalMemoryBufferCreateInfo(api_dump, *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(object), (api_dump.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));
+            dump_VkExportMemoryAllocateInfo(api_dump, *reinterpret_cast<const VkExportMemoryAllocateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalFenceInfo(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(object), (api_dump.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));
+            dump_VkExternalFenceProperties(api_dump, *reinterpret_cast<const VkExternalFenceProperties*>(object), (api_dump.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));
+            dump_VkExportFenceCreateInfo(api_dump, *reinterpret_cast<const VkExportFenceCreateInfo*>(object), (api_dump.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));
+            dump_VkExportSemaphoreCreateInfo(api_dump, *reinterpret_cast<const VkExportSemaphoreCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalSemaphoreInfo(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(object), (api_dump.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));
+            dump_VkExternalSemaphoreProperties(api_dump, *reinterpret_cast<const VkExternalSemaphoreProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSubgroupProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDevice16BitStorageFeatures(api_dump, *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVariablePointersFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(object), (api_dump.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));
+            dump_VkDescriptorUpdateTemplateCreateInfo(api_dump, *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance3Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(object), (api_dump.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));
+            dump_VkDescriptorSetLayoutSupport(api_dump, *reinterpret_cast<const VkDescriptorSetLayoutSupport*>(object), (api_dump.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));
+            dump_VkSamplerYcbcrConversionCreateInfo(api_dump, *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(object), (api_dump.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));
+            dump_VkSamplerYcbcrConversionInfo(api_dump, *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSamplerYcbcrConversionFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(object), (api_dump.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));
+            dump_VkSamplerYcbcrConversionImageFormatProperties(api_dump, *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(object), (api_dump.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));
+            dump_VkDeviceGroupRenderPassBeginInfo(api_dump, *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePointClippingProperties(api_dump, *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(object), (api_dump.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));
+            dump_VkRenderPassInputAttachmentAspectCreateInfo(api_dump, *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(object), (api_dump.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));
+            dump_VkPipelineTessellationDomainOriginStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(object), (api_dump.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));
+            dump_VkRenderPassMultiviewCreateInfo(api_dump, *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultiviewFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultiviewProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderDrawParametersFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderDrawParametersFeatures*" : "VkPhysicalDeviceShaderDrawParametersFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(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));
+            dump_VkPhysicalDeviceVulkan11Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan11Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan12Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan12Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(object), (api_dump.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));
+            dump_VkImageFormatListCreateInfo(api_dump, *reinterpret_cast<const VkImageFormatListCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkImageFormatListCreateInfo*" : "VkImageFormatListCreateInfo"), "pNext", indents, reinterpret_cast<const VkImageFormatListCreateInfo*>(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));
+            dump_VkPhysicalDeviceDriverProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceDriverProperties*" : "VkPhysicalDeviceDriverProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(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));
+            dump_VkPhysicalDeviceVulkanMemoryModelFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceHostQueryResetFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTimelineSemaphoreFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTimelineSemaphoreProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(object), (api_dump.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));
+            dump_VkSemaphoreTypeCreateInfo(api_dump, *reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(object), (api_dump.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));
+            dump_VkTimelineSemaphoreSubmitInfo(api_dump, *reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(object), (api_dump.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));
+            dump_VkSemaphoreWaitInfo(api_dump, *reinterpret_cast<const VkSemaphoreWaitInfo*>(object), (api_dump.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));
+            dump_VkSemaphoreSignalInfo(api_dump, *reinterpret_cast<const VkSemaphoreSignalInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceBufferDeviceAddressFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(object), (api_dump.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));
+            dump_VkBufferDeviceAddressInfo(api_dump, *reinterpret_cast<const VkBufferDeviceAddressInfo*>(object), (api_dump.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));
+            dump_VkBufferOpaqueCaptureAddressCreateInfo(api_dump, *reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(object), (api_dump.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));
+            dump_VkMemoryOpaqueCaptureAddressAllocateInfo(api_dump, *reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(object), (api_dump.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));
+            dump_VkDeviceMemoryOpaqueCaptureAddressInfo(api_dump, *reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDevice8BitStorageFeatures(api_dump, *reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderAtomicInt64Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderFloat16Int8Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFloatControlsProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(object), (api_dump.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));
+            dump_VkDescriptorSetLayoutBindingFlagsCreateInfo(api_dump, *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorIndexingFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorIndexingProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(object), (api_dump.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));
+            dump_VkDescriptorSetVariableDescriptorCountAllocateInfo(api_dump, *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(object), (api_dump.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));
+            dump_VkDescriptorSetVariableDescriptorCountLayoutSupport(api_dump, *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceScalarBlockLayoutFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(object), (api_dump.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));
+            dump_VkSamplerReductionModeCreateInfo(api_dump, *reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSamplerFilterMinmaxProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(object), (api_dump.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));
+            dump_VkAttachmentDescription2(api_dump, *reinterpret_cast<const VkAttachmentDescription2*>(object), (api_dump.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));
+            dump_VkAttachmentReference2(api_dump, *reinterpret_cast<const VkAttachmentReference2*>(object), (api_dump.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));
+            dump_VkSubpassDescription2(api_dump, *reinterpret_cast<const VkSubpassDescription2*>(object), (api_dump.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));
+            dump_VkSubpassDependency2(api_dump, *reinterpret_cast<const VkSubpassDependency2*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkSubpassDependency2*" : "VkSubpassDependency2"), "pNext", indents, reinterpret_cast<const VkSubpassDependency2*>(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));
+            dump_VkRenderPassCreateInfo2(api_dump, *reinterpret_cast<const VkRenderPassCreateInfo2*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkRenderPassCreateInfo2*" : "VkRenderPassCreateInfo2"), "pNext", indents, reinterpret_cast<const VkRenderPassCreateInfo2*>(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));
+            dump_VkSubpassBeginInfo(api_dump, *reinterpret_cast<const VkSubpassBeginInfo*>(object), (api_dump.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));
+            dump_VkSubpassEndInfo(api_dump, *reinterpret_cast<const VkSubpassEndInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkSubpassEndInfo*" : "VkSubpassEndInfo"), "pNext", indents, reinterpret_cast<const VkSubpassEndInfo*>(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));
+            dump_VkSubpassDescriptionDepthStencilResolve(api_dump, *reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDepthStencilResolveProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(object), (api_dump.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));
+            dump_VkImageStencilUsageCreateInfo(api_dump, *reinterpret_cast<const VkImageStencilUsageCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImagelessFramebufferFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(object), (api_dump.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));
+            dump_VkFramebufferAttachmentImageInfo(api_dump, *reinterpret_cast<const VkFramebufferAttachmentImageInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkFramebufferAttachmentImageInfo*" : "VkFramebufferAttachmentImageInfo"), "pNext", indents, reinterpret_cast<const VkFramebufferAttachmentImageInfo*>(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));
+            dump_VkFramebufferAttachmentsCreateInfo(api_dump, *reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkFramebufferAttachmentsCreateInfo*" : "VkFramebufferAttachmentsCreateInfo"), "pNext", indents, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(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));
+            dump_VkRenderPassAttachmentBeginInfo(api_dump, *reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkRenderPassAttachmentBeginInfo*" : "VkRenderPassAttachmentBeginInfo"), "pNext", indents, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(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));
+            dump_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(object), (api_dump.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));
+            dump_VkAttachmentReferenceStencilLayout(api_dump, *reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(object), (api_dump.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));
+            dump_VkAttachmentDescriptionStencilLayout(api_dump, *reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan13Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan13Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceToolProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceToolProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePrivateDataFeatures(api_dump, *reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(object), (api_dump.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));
+            dump_VkDevicePrivateDataCreateInfo(api_dump, *reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(object), (api_dump.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));
+            dump_VkPrivateDataSlotCreateInfo(api_dump, *reinterpret_cast<const VkPrivateDataSlotCreateInfo*>(object), (api_dump.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));
+            dump_VkMemoryBarrier2(api_dump, *reinterpret_cast<const VkMemoryBarrier2*>(object), (api_dump.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));
+            dump_VkBufferMemoryBarrier2(api_dump, *reinterpret_cast<const VkBufferMemoryBarrier2*>(object), (api_dump.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));
+            dump_VkImageMemoryBarrier2(api_dump, *reinterpret_cast<const VkImageMemoryBarrier2*>(object), (api_dump.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));
+            dump_VkDependencyInfo(api_dump, *reinterpret_cast<const VkDependencyInfo*>(object), (api_dump.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));
+            dump_VkSemaphoreSubmitInfo(api_dump, *reinterpret_cast<const VkSemaphoreSubmitInfo*>(object), (api_dump.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));
+            dump_VkCommandBufferSubmitInfo(api_dump, *reinterpret_cast<const VkCommandBufferSubmitInfo*>(object), (api_dump.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));
+            dump_VkSubmitInfo2(api_dump, *reinterpret_cast<const VkSubmitInfo2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSynchronization2Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(object), (api_dump.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));
+            dump_VkBufferCopy2(api_dump, *reinterpret_cast<const VkBufferCopy2*>(object), (api_dump.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));
+            dump_VkCopyBufferInfo2(api_dump, *reinterpret_cast<const VkCopyBufferInfo2*>(object), (api_dump.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));
+            dump_VkImageCopy2(api_dump, *reinterpret_cast<const VkImageCopy2*>(object), (api_dump.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));
+            dump_VkCopyImageInfo2(api_dump, *reinterpret_cast<const VkCopyImageInfo2*>(object), (api_dump.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));
+            dump_VkBufferImageCopy2(api_dump, *reinterpret_cast<const VkBufferImageCopy2*>(object), (api_dump.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));
+            dump_VkCopyBufferToImageInfo2(api_dump, *reinterpret_cast<const VkCopyBufferToImageInfo2*>(object), (api_dump.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));
+            dump_VkCopyImageToBufferInfo2(api_dump, *reinterpret_cast<const VkCopyImageToBufferInfo2*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(object), (api_dump.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));
+            dump_VkFormatProperties3(api_dump, *reinterpret_cast<const VkFormatProperties3*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance4Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance4Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(object), (api_dump.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));
+            dump_VkDeviceBufferMemoryRequirements(api_dump, *reinterpret_cast<const VkDeviceBufferMemoryRequirements*>(object), (api_dump.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));
+            dump_VkDeviceImageMemoryRequirements(api_dump, *reinterpret_cast<const VkDeviceImageMemoryRequirements*>(object), (api_dump.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));
+            dump_VkPipelineCreationFeedbackCreateInfo(api_dump, *reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderTerminateInvocationFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineCreationCacheControlFeatures(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageRobustnessFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSubgroupSizeControlFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSubgroupSizeControlProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(object), (api_dump.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));
+            dump_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(api_dump, *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceInlineUniformBlockFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceInlineUniformBlockProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(object), (api_dump.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));
+            dump_VkWriteDescriptorSetInlineUniformBlock(api_dump, *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(object), (api_dump.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));
+            dump_VkDescriptorPoolInlineUniformBlockCreateInfo(api_dump, *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderIntegerDotProductFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderIntegerDotProductProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTexelBufferAlignmentProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(object), (api_dump.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));
+            dump_VkImageBlit2(api_dump, *reinterpret_cast<const VkImageBlit2*>(object), (api_dump.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));
+            dump_VkBlitImageInfo2(api_dump, *reinterpret_cast<const VkBlitImageInfo2*>(object), (api_dump.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));
+            dump_VkImageResolve2(api_dump, *reinterpret_cast<const VkImageResolve2*>(object), (api_dump.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));
+            dump_VkResolveImageInfo2(api_dump, *reinterpret_cast<const VkResolveImageInfo2*>(object), (api_dump.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));
+            dump_VkRenderingAttachmentInfo(api_dump, *reinterpret_cast<const VkRenderingAttachmentInfo*>(object), (api_dump.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));
+            dump_VkRenderingInfo(api_dump, *reinterpret_cast<const VkRenderingInfo*>(object), (api_dump.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));
+            dump_VkPipelineRenderingCreateInfo(api_dump, *reinterpret_cast<const VkPipelineRenderingCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDynamicRenderingFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(object), (api_dump.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));
+            dump_VkCommandBufferInheritanceRenderingInfo(api_dump, *reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan14Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVulkan14Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(object), (api_dump.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));
+            dump_VkDeviceQueueGlobalPriorityCreateInfo(api_dump, *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceGlobalPriorityQueryFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(object), (api_dump.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));
+            dump_VkQueueFamilyGlobalPriorityProperties(api_dump, *reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceIndexTypeUint8Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(object), (api_dump.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));
+            dump_VkMemoryMapInfo(api_dump, *reinterpret_cast<const VkMemoryMapInfo*>(object), (api_dump.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));
+            dump_VkMemoryUnmapInfo(api_dump, *reinterpret_cast<const VkMemoryUnmapInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance5Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance5Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance5Properties*" : "VkPhysicalDeviceMaintenance5Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(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));
+            dump_VkImageSubresource2(api_dump, *reinterpret_cast<const VkImageSubresource2*>(object), (api_dump.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));
+            dump_VkDeviceImageSubresourceInfo(api_dump, *reinterpret_cast<const VkDeviceImageSubresourceInfo*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkDeviceImageSubresourceInfo*" : "VkDeviceImageSubresourceInfo"), "pNext", indents, reinterpret_cast<const VkDeviceImageSubresourceInfo*>(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));
+            dump_VkSubresourceLayout2(api_dump, *reinterpret_cast<const VkSubresourceLayout2*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkSubresourceLayout2*" : "VkSubresourceLayout2"), "pNext", indents, reinterpret_cast<const VkSubresourceLayout2*>(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));
+            dump_VkBufferUsageFlags2CreateInfo(api_dump, *reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance6Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance6Properties(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(object), (api_dump.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));
+            dump_VkBindMemoryStatus(api_dump, *reinterpret_cast<const VkBindMemoryStatus*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceHostImageCopyFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceHostImageCopyProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(object), (api_dump.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));
+            dump_VkMemoryToImageCopy(api_dump, *reinterpret_cast<const VkMemoryToImageCopy*>(object), (api_dump.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));
+            dump_VkImageToMemoryCopy(api_dump, *reinterpret_cast<const VkImageToMemoryCopy*>(object), (api_dump.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));
+            dump_VkCopyMemoryToImageInfo(api_dump, *reinterpret_cast<const VkCopyMemoryToImageInfo*>(object), (api_dump.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));
+            dump_VkCopyImageToMemoryInfo(api_dump, *reinterpret_cast<const VkCopyImageToMemoryInfo*>(object), (api_dump.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));
+            dump_VkCopyImageToImageInfo(api_dump, *reinterpret_cast<const VkCopyImageToImageInfo*>(object), (api_dump.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));
+            dump_VkHostImageLayoutTransitionInfo(api_dump, *reinterpret_cast<const VkHostImageLayoutTransitionInfo*>(object), (api_dump.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));
+            dump_VkSubresourceHostMemcpySize(api_dump, *reinterpret_cast<const VkSubresourceHostMemcpySize*>(object), (api_dump.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));
+            dump_VkHostImageCopyDevicePerformanceQuery(api_dump, *reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderSubgroupRotateFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderFloatControls2Features(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderExpectAssumeFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(object), (api_dump.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));
+            dump_VkPipelineCreateFlags2CreateInfo(api_dump, *reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePushDescriptorProperties(api_dump, *reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(object), (api_dump.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));
+            dump_VkBindDescriptorSetsInfo(api_dump, *reinterpret_cast<const VkBindDescriptorSetsInfo*>(object), (api_dump.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));
+            dump_VkPushConstantsInfo(api_dump, *reinterpret_cast<const VkPushConstantsInfo*>(object), (api_dump.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));
+            dump_VkPushDescriptorSetInfo(api_dump, *reinterpret_cast<const VkPushDescriptorSetInfo*>(object), (api_dump.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));
+            dump_VkPushDescriptorSetWithTemplateInfo(api_dump, *reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineProtectedAccessFeatures(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineRobustnessFeatures(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineRobustnessProperties(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(object), (api_dump.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));
+            dump_VkPipelineRobustnessCreateInfo(api_dump, *reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLineRasterizationFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLineRasterizationProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(object), (api_dump.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));
+            dump_VkPipelineRasterizationLineStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVertexAttributeDivisorProperties(api_dump, *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(object), (api_dump.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));
+            dump_VkPipelineVertexInputDivisorStateCreateInfo(api_dump, *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVertexAttributeDivisorFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(object), (api_dump.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));
+            dump_VkRenderingAreaInfo(api_dump, *reinterpret_cast<const VkRenderingAreaInfo*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(api_dump, *reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(object), (api_dump.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));
+            dump_VkRenderingAttachmentLocationInfo(api_dump, *reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(object), (api_dump.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));
+            dump_VkRenderingInputAttachmentIndexInfo(api_dump, *reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(object), (api_dump.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));
+            dump_VkSwapchainCreateInfoKHR(api_dump, *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPresentInfoKHR(api_dump, *reinterpret_cast<const VkPresentInfoKHR*>(object), (api_dump.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));
+            dump_VkImageSwapchainCreateInfoKHR(api_dump, *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkBindImageMemorySwapchainInfoKHR(api_dump, *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(object), (api_dump.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));
+            dump_VkAcquireNextImageInfoKHR(api_dump, *reinterpret_cast<const VkAcquireNextImageInfoKHR*>(object), (api_dump.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));
+            dump_VkDeviceGroupPresentCapabilitiesKHR(api_dump, *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkDeviceGroupPresentInfoKHR(api_dump, *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(object), (api_dump.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));
+            dump_VkDeviceGroupSwapchainCreateInfoKHR(api_dump, *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkDisplayModeCreateInfoKHR(api_dump, *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkDisplaySurfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkDisplayPresentInfoKHR(api_dump, *reinterpret_cast<const VkDisplayPresentInfoKHR*>(object), (api_dump.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));
+            dump_VkXlibSurfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkXcbSurfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkWaylandSurfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkAndroidSurfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkWin32SurfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkQueueFamilyQueryResultStatusPropertiesKHR(api_dump, *reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(object), (api_dump.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));
+            dump_VkQueueFamilyVideoPropertiesKHR(api_dump, *reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoProfileListInfoKHR(api_dump, *reinterpret_cast<const VkVideoProfileListInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoFormatInfoKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoFormatPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoFormatPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoPictureResourceInfoKHR(api_dump, *reinterpret_cast<const VkVideoPictureResourceInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoReferenceSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoReferenceSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoSessionMemoryRequirementsKHR(api_dump, *reinterpret_cast<const VkVideoSessionMemoryRequirementsKHR*>(object), (api_dump.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));
+            dump_VkBindVideoSessionMemoryInfoKHR(api_dump, *reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoSessionCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoSessionCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoSessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoSessionParametersUpdateInfoKHR(api_dump, *reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoBeginCodingInfoKHR(api_dump, *reinterpret_cast<const VkVideoBeginCodingInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEndCodingInfoKHR(api_dump, *reinterpret_cast<const VkVideoEndCodingInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoCodingControlInfoKHR(api_dump, *reinterpret_cast<const VkVideoCodingControlInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeUsageInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264QualityLevelPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264SessionCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264SessionParametersAddInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264SessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264SessionParametersGetInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264NaluSliceInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264NaluSliceInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264DpbSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264RateControlInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264RateControlLayerInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264GopRemainingFrameInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265SessionCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265QualityLevelPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265SessionParametersAddInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265SessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265SessionParametersGetInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265DpbSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265RateControlInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265RateControlLayerInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265GopRemainingFrameInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264SessionParametersAddInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264SessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264DpbSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkImportMemoryWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkExportMemoryWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkMemoryWin32HandlePropertiesKHR(api_dump, *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(object), (api_dump.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));
+            dump_VkMemoryGetWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkImportMemoryFdInfoKHR(api_dump, *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(object), (api_dump.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));
+            dump_VkMemoryFdPropertiesKHR(api_dump, *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(object), (api_dump.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));
+            dump_VkMemoryGetFdInfoKHR(api_dump, *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(object), (api_dump.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));
+            dump_VkWin32KeyedMutexAcquireReleaseInfoKHR(api_dump, *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(object), (api_dump.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));
+            dump_VkImportSemaphoreWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkExportSemaphoreWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkD3D12FenceSubmitInfoKHR(api_dump, *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(object), (api_dump.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));
+            dump_VkSemaphoreGetWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkImportSemaphoreFdInfoKHR(api_dump, *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(object), (api_dump.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));
+            dump_VkSemaphoreGetFdInfoKHR(api_dump, *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(object), (api_dump.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));
+            dump_VkPresentRegionsKHR(api_dump, *reinterpret_cast<const VkPresentRegionsKHR*>(object), (api_dump.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));
+            dump_VkSharedPresentSurfaceCapabilitiesKHR(api_dump, *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkImportFenceWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkExportFenceWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkFenceGetWin32HandleInfoKHR(api_dump, *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(object), (api_dump.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));
+            dump_VkImportFenceFdInfoKHR(api_dump, *reinterpret_cast<const VkImportFenceFdInfoKHR*>(object), (api_dump.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));
+            dump_VkFenceGetFdInfoKHR(api_dump, *reinterpret_cast<const VkFenceGetFdInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePerformanceQueryFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePerformanceQueryPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPerformanceCounterKHR(api_dump, *reinterpret_cast<const VkPerformanceCounterKHR*>(object), (api_dump.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));
+            dump_VkPerformanceCounterDescriptionKHR(api_dump, *reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>(object), (api_dump.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));
+            dump_VkQueryPoolPerformanceCreateInfoKHR(api_dump, *reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkAcquireProfilingLockInfoKHR(api_dump, *reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>(object), (api_dump.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));
+            dump_VkPerformanceQuerySubmitInfoKHR(api_dump, *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSurfaceInfo2KHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(object), (api_dump.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));
+            dump_VkSurfaceCapabilities2KHR(api_dump, *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(object), (api_dump.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));
+            dump_VkSurfaceFormat2KHR(api_dump, *reinterpret_cast<const VkSurfaceFormat2KHR*>(object), (api_dump.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));
+            dump_VkDisplayProperties2KHR(api_dump, *reinterpret_cast<const VkDisplayProperties2KHR*>(object), (api_dump.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));
+            dump_VkDisplayPlaneProperties2KHR(api_dump, *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(object), (api_dump.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));
+            dump_VkDisplayModeProperties2KHR(api_dump, *reinterpret_cast<const VkDisplayModeProperties2KHR*>(object), (api_dump.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));
+            dump_VkDisplayPlaneInfo2KHR(api_dump, *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(object), (api_dump.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));
+            dump_VkDisplayPlaneCapabilities2KHR(api_dump, *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderBfloat16FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePortabilitySubsetFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePortabilitySubsetPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderClockFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265SessionParametersAddInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265SessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265DpbSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkFragmentShadingRateAttachmentInfoKHR(api_dump, *reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineFragmentShadingRateStateCreateInfoKHR(api_dump, *reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShadingRateKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateKHR*>(object), (api_dump.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));
+            dump_VkRenderingFragmentShadingRateAttachmentInfoKHR(api_dump, *reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkRenderingFragmentShadingRateAttachmentInfoKHR*" : "VkRenderingFragmentShadingRateAttachmentInfoKHR"), "pNext", indents, reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(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));
+            dump_VkPhysicalDeviceShaderQuadControlFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(object), (api_dump.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));
+            dump_VkSurfaceProtectedCapabilitiesKHR(api_dump, *reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentWaitFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPipelineInfoKHR(api_dump, *reinterpret_cast<const VkPipelineInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineExecutablePropertiesKHR(api_dump, *reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>(object), (api_dump.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));
+            dump_VkPipelineExecutableInfoKHR(api_dump, *reinterpret_cast<const VkPipelineExecutableInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineExecutableStatisticKHR(api_dump, *reinterpret_cast<const VkPipelineExecutableStatisticKHR*>(object), (api_dump.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));
+            dump_VkPipelineExecutableInternalRepresentationKHR(api_dump, *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>(object), (api_dump.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));
+            dump_VkPipelineLibraryCreateInfoKHR(api_dump, *reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPresentIdKHR(api_dump, *reinterpret_cast<const VkPresentIdKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentIdFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(api_dump, *reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeUsageInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeRateControlLayerInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeRateControlInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeQualityLevelPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeQualityLevelPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeQualityLevelInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeSessionParametersGetInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeSessionParametersFeedbackInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeSessionParametersFeedbackInfoKHR*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkVideoEncodeSessionParametersFeedbackInfoKHR*" : "VkVideoEncodeSessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeSessionParametersFeedbackInfoKHR*>(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));
+            dump_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(object), (api_dump.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));
+            dump_VkSurfaceCapabilitiesPresentId2KHR(api_dump, *reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR*>(object), (api_dump.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));
+            dump_VkPresentId2KHR(api_dump, *reinterpret_cast<const VkPresentId2KHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentId2FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(object), (api_dump.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));
+            dump_VkSurfaceCapabilitiesPresentWait2KHR(api_dump, *reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentWait2FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPresentWait2InfoKHR(api_dump, *reinterpret_cast<const VkPresentWait2InfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineBinaryFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineBinaryPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR*>(object), (api_dump.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));
+            dump_VkDevicePipelineBinaryInternalCacheControlKHR(api_dump, *reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR*>(object), (api_dump.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));
+            dump_VkPipelineBinaryKeyKHR(api_dump, *reinterpret_cast<const VkPipelineBinaryKeyKHR*>(object), (api_dump.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));
+            dump_VkPipelineCreateInfoKHR(api_dump, *reinterpret_cast<const VkPipelineCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineBinaryCreateInfoKHR(api_dump, *reinterpret_cast<const VkPipelineBinaryCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineBinaryInfoKHR(api_dump, *reinterpret_cast<const VkPipelineBinaryInfoKHR*>(object), (api_dump.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));
+            dump_VkReleaseCapturedPipelineDataInfoKHR(api_dump, *reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineBinaryDataInfoKHR(api_dump, *reinterpret_cast<const VkPipelineBinaryDataInfoKHR*>(object), (api_dump.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));
+            dump_VkPipelineBinaryHandlesInfoKHR(api_dump, *reinterpret_cast<const VkPipelineBinaryHandlesInfoKHR*>(object), (api_dump.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));
+            dump_VkSurfacePresentModeKHR(api_dump, *reinterpret_cast<const VkSurfacePresentModeKHR*>(object), (api_dump.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));
+            dump_VkSurfacePresentScalingCapabilitiesKHR(api_dump, *reinterpret_cast<const VkSurfacePresentScalingCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkSurfacePresentModeCompatibilityKHR(api_dump, *reinterpret_cast<const VkSurfacePresentModeCompatibilityKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(object), (api_dump.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));
+            dump_VkSwapchainPresentFenceInfoKHR(api_dump, *reinterpret_cast<const VkSwapchainPresentFenceInfoKHR*>(object), (api_dump.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));
+            dump_VkSwapchainPresentModesCreateInfoKHR(api_dump, *reinterpret_cast<const VkSwapchainPresentModesCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkSwapchainPresentModeInfoKHR(api_dump, *reinterpret_cast<const VkSwapchainPresentModeInfoKHR*>(object), (api_dump.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));
+            dump_VkSwapchainPresentScalingCreateInfoKHR(api_dump, *reinterpret_cast<const VkSwapchainPresentScalingCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkReleaseSwapchainImagesInfoKHR(api_dump, *reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(object), (api_dump.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));
+            dump_VkCooperativeMatrixPropertiesKHR(api_dump, *reinterpret_cast<const VkCooperativeMatrixPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeAV1ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeAV1CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeAV1SessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeAV1PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeAV1DpbSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1QualityLevelPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1SessionCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1SessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1DpbSlotInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1GopRemainingFrameInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1RateControlInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1RateControlLayerInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeVP9ProfileInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeVP9CapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeVP9PictureInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoInlineQueryInfoKHR(api_dump, *reinterpret_cast<const VkVideoInlineQueryInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(object), (api_dump.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));
+            dump_VkAttachmentFeedbackLoopInfoEXT(api_dump, *reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT*>(object), (api_dump.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));
+            dump_VkCalibratedTimestampInfoKHR(api_dump, *reinterpret_cast<const VkCalibratedTimestampInfoKHR*>(object), (api_dump.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));
+            dump_VkSetDescriptorBufferOffsetsInfoEXT(api_dump, *reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT*>(object), (api_dump.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));
+            dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(api_dump, *reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*>(object), (api_dump.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));
+            dump_VkCopyMemoryIndirectInfoKHR(api_dump, *reinterpret_cast<const VkCopyMemoryIndirectInfoKHR*>(object), (api_dump.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));
+            dump_VkCopyMemoryToImageIndirectInfoKHR(api_dump, *reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeIntraRefreshCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeIntraRefreshCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeSessionIntraRefreshCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeIntraRefreshInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeIntraRefreshInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoReferenceIntraRefreshInfoKHR(api_dump, *reinterpret_cast<const VkVideoReferenceIntraRefreshInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeQuantizationMapCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoFormatQuantizationMapPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeQuantizationMapInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(api_dump, *reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoFormatH265QuantizationMapPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR*>(object), (api_dump.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));
+            dump_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(api_dump, *reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(object), (api_dump.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));
+            dump_VkVideoFormatAV1QuantizationMapPropertiesKHR(api_dump, *reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance7FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance7PropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLayeredApiPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLayeredApiPropertiesListKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*" : "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(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));
+            dump_VkMemoryBarrierAccessFlags3KHR(api_dump, *reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance8FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderFmaFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance9FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance9PropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR*>(object), (api_dump.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));
+            dump_VkQueueFamilyOwnershipTransferPropertiesKHR(api_dump, *reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH264InlineSessionParametersInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeH265InlineSessionParametersInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR*>(object), (api_dump.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));
+            dump_VkVideoDecodeAV1InlineSessionParametersInfoKHR(api_dump, *reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkVideoDecodeAV1InlineSessionParametersInfoKHR*" : "VkVideoDecodeAV1InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(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));
+            dump_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRobustness2FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRobustness2PropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*" : "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(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));
+            dump_VkPhysicalDeviceMaintenance10FeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMaintenance10PropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceMaintenance10PropertiesKHR*>(object), (api_dump.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));
+            dump_VkRenderingEndInfoKHR(api_dump, *reinterpret_cast<const VkRenderingEndInfoKHR*>(object), (api_dump.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));
+            dump_VkRenderingAttachmentFlagsInfoKHR(api_dump, *reinterpret_cast<const VkRenderingAttachmentFlagsInfoKHR*>(object), (api_dump.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));
+            dump_VkResolveImageModeInfoKHR(api_dump, *reinterpret_cast<const VkResolveImageModeInfoKHR*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkResolveImageModeInfoKHR*" : "VkResolveImageModeInfoKHR"), "pNext", indents, reinterpret_cast<const VkResolveImageModeInfoKHR*>(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));
+            dump_VkDebugReportCallbackCreateInfoEXT(api_dump, *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPipelineRasterizationStateRasterizationOrderAMD(api_dump, *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(object), (api_dump.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));
+            dump_VkDebugMarkerObjectNameInfoEXT(api_dump, *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(object), (api_dump.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));
+            dump_VkDebugMarkerObjectTagInfoEXT(api_dump, *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(object), (api_dump.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));
+            dump_VkDebugMarkerMarkerInfoEXT(api_dump, *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(object), (api_dump.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));
+            dump_VkDedicatedAllocationImageCreateInfoNV(api_dump, *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(object), (api_dump.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));
+            dump_VkDedicatedAllocationBufferCreateInfoNV(api_dump, *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(object), (api_dump.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));
+            dump_VkDedicatedAllocationMemoryAllocateInfoNV(api_dump, *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTransformFeedbackFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTransformFeedbackPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineRasterizationStateStreamCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkCuModuleCreateInfoNVX(api_dump, *reinterpret_cast<const VkCuModuleCreateInfoNVX*>(object), (api_dump.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));
+            dump_VkCuModuleTexturingModeCreateInfoNVX(api_dump, *reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX*>(object), (api_dump.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));
+            dump_VkCuFunctionCreateInfoNVX(api_dump, *reinterpret_cast<const VkCuFunctionCreateInfoNVX*>(object), (api_dump.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));
+            dump_VkCuLaunchInfoNVX(api_dump, *reinterpret_cast<const VkCuLaunchInfoNVX*>(object), (api_dump.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));
+            dump_VkImageViewHandleInfoNVX(api_dump, *reinterpret_cast<const VkImageViewHandleInfoNVX*>(object), (api_dump.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));
+            dump_VkImageViewAddressPropertiesNVX(api_dump, *reinterpret_cast<const VkImageViewAddressPropertiesNVX*>(object), (api_dump.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));
+            dump_VkTextureLODGatherFormatPropertiesAMD(api_dump, *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(object), (api_dump.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));
+            dump_VkStreamDescriptorSurfaceCreateInfoGGP(api_dump, *reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCornerSampledImageFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(object), (api_dump.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));
+            dump_VkExternalMemoryImageCreateInfoNV(api_dump, *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(object), (api_dump.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));
+            dump_VkExportMemoryAllocateInfoNV(api_dump, *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(object), (api_dump.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));
+            dump_VkImportMemoryWin32HandleInfoNV(api_dump, *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(object), (api_dump.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));
+            dump_VkExportMemoryWin32HandleInfoNV(api_dump, *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(object), (api_dump.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));
+            dump_VkWin32KeyedMutexAcquireReleaseInfoNV(api_dump, *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(object), (api_dump.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));
+            dump_VkValidationFlagsEXT(api_dump, *reinterpret_cast<const VkValidationFlagsEXT*>(object), (api_dump.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));
+            dump_VkViSurfaceCreateInfoNN(api_dump, *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(object), (api_dump.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));
+            dump_VkImageViewASTCDecodeModeEXT(api_dump, *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceASTCDecodeFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(object), (api_dump.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));
+            dump_VkConditionalRenderingBeginInfoEXT(api_dump, *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceConditionalRenderingFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(object), (api_dump.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));
+            dump_VkCommandBufferInheritanceConditionalRenderingInfoEXT(api_dump, *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(object), (api_dump.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));
+            dump_VkPipelineViewportWScalingStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkSurfaceCapabilities2EXT(api_dump, *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(object), (api_dump.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));
+            dump_VkDisplayPowerInfoEXT(api_dump, *reinterpret_cast<const VkDisplayPowerInfoEXT*>(object), (api_dump.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));
+            dump_VkDeviceEventInfoEXT(api_dump, *reinterpret_cast<const VkDeviceEventInfoEXT*>(object), (api_dump.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));
+            dump_VkDisplayEventInfoEXT(api_dump, *reinterpret_cast<const VkDisplayEventInfoEXT*>(object), (api_dump.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));
+            dump_VkSwapchainCounterCreateInfoEXT(api_dump, *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPresentTimesInfoGOOGLE(api_dump, *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(object), (api_dump.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));
+            dump_VkMultiviewPerViewAttributesInfoNVX(api_dump, *reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(object), (api_dump.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));
+            dump_VkPipelineViewportSwizzleStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDiscardRectanglePropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineDiscardRectangleStateCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineRasterizationConservativeStateCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDepthClipEnableFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPipelineRasterizationDepthClipStateCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkHdrMetadataEXT(api_dump, *reinterpret_cast<const VkHdrMetadataEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(api_dump, *reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(object), (api_dump.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));
+            dump_VkIOSSurfaceCreateInfoMVK(api_dump, *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(object), (api_dump.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));
+            dump_VkMacOSSurfaceCreateInfoMVK(api_dump, *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(object), (api_dump.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));
+            dump_VkDebugUtilsLabelEXT(api_dump, *reinterpret_cast<const VkDebugUtilsLabelEXT*>(object), (api_dump.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));
+            dump_VkDebugUtilsObjectNameInfoEXT(api_dump, *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(object), (api_dump.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));
+            dump_VkDebugUtilsMessengerCallbackDataEXT(api_dump, *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(object), (api_dump.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));
+            dump_VkDebugUtilsMessengerCreateInfoEXT(api_dump, *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkDebugUtilsObjectTagInfoEXT(api_dump, *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(object), (api_dump.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));
+            dump_VkAndroidHardwareBufferUsageANDROID(api_dump, *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(object), (api_dump.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));
+            dump_VkAndroidHardwareBufferPropertiesANDROID(api_dump, *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(object), (api_dump.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));
+            dump_VkAndroidHardwareBufferFormatPropertiesANDROID(api_dump, *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(object), (api_dump.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));
+            dump_VkImportAndroidHardwareBufferInfoANDROID(api_dump, *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(object), (api_dump.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));
+            dump_VkMemoryGetAndroidHardwareBufferInfoANDROID(api_dump, *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(object), (api_dump.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));
+            dump_VkExternalFormatANDROID(api_dump, *reinterpret_cast<const VkExternalFormatANDROID*>(object), (api_dump.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));
+            dump_VkAndroidHardwareBufferFormatProperties2ANDROID(api_dump, *reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatProperties2ANDROID*" : "VkAndroidHardwareBufferFormatProperties2ANDROID"), "pNext", indents, reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(object));
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #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));
+            dump_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(object), (api_dump.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));
+            dump_VkExecutionGraphPipelineScratchSizeAMDX(api_dump, *reinterpret_cast<const VkExecutionGraphPipelineScratchSizeAMDX*>(object), (api_dump.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));
+            dump_VkExecutionGraphPipelineCreateInfoAMDX(api_dump, *reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX*>(object), (api_dump.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));
+            dump_VkPipelineShaderStageNodeCreateInfoAMDX(api_dump, *reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX*>(object), (api_dump.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));
+            dump_VkTexelBufferDescriptorInfoEXT(api_dump, *reinterpret_cast<const VkTexelBufferDescriptorInfoEXT*>(object), (api_dump.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));
+            dump_VkImageDescriptorInfoEXT(api_dump, *reinterpret_cast<const VkImageDescriptorInfoEXT*>(object), (api_dump.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));
+            dump_VkTensorViewCreateInfoARM(api_dump, *reinterpret_cast<const VkTensorViewCreateInfoARM*>(object), (api_dump.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));
+            dump_VkResourceDescriptorInfoEXT(api_dump, *reinterpret_cast<const VkResourceDescriptorInfoEXT*>(object), (api_dump.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));
+            dump_VkBindHeapInfoEXT(api_dump, *reinterpret_cast<const VkBindHeapInfoEXT*>(object), (api_dump.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));
+            dump_VkPushDataInfoEXT(api_dump, *reinterpret_cast<const VkPushDataInfoEXT*>(object), (api_dump.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));
+            dump_VkDescriptorSetAndBindingMappingEXT(api_dump, *reinterpret_cast<const VkDescriptorSetAndBindingMappingEXT*>(object), (api_dump.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));
+            dump_VkShaderDescriptorSetAndBindingMappingInfoEXT(api_dump, *reinterpret_cast<const VkShaderDescriptorSetAndBindingMappingInfoEXT*>(object), (api_dump.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));
+            dump_VkOpaqueCaptureDataCreateInfoEXT(api_dump, *reinterpret_cast<const VkOpaqueCaptureDataCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorHeapFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorHeapPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorHeapPropertiesEXT*>(object), (api_dump.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));
+            dump_VkCommandBufferInheritanceDescriptorHeapInfoEXT(api_dump, *reinterpret_cast<const VkCommandBufferInheritanceDescriptorHeapInfoEXT*>(object), (api_dump.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));
+            dump_VkSamplerCustomBorderColorIndexCreateInfoEXT(api_dump, *reinterpret_cast<const VkSamplerCustomBorderColorIndexCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkSamplerCustomBorderColorCreateInfoEXT(api_dump, *reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkIndirectCommandsLayoutPushDataTokenNV(api_dump, *reinterpret_cast<const VkIndirectCommandsLayoutPushDataTokenNV*>(object), (api_dump.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));
+            dump_VkSubsampledImageFormatPropertiesEXT(api_dump, *reinterpret_cast<const VkSubsampledImageFormatPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorHeapTensorPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*>(object), (api_dump.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));
+            dump_VkAttachmentSampleCountInfoAMD(api_dump, *reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(object), (api_dump.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));
+            dump_VkSampleLocationsInfoEXT(api_dump, *reinterpret_cast<const VkSampleLocationsInfoEXT*>(object), (api_dump.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));
+            dump_VkRenderPassSampleLocationsBeginInfoEXT(api_dump, *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(object), (api_dump.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));
+            dump_VkPipelineSampleLocationsStateCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSampleLocationsPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(object), (api_dump.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));
+            dump_VkMultisamplePropertiesEXT(api_dump, *reinterpret_cast<const VkMultisamplePropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineColorBlendAdvancedStateCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPipelineCoverageToColorStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPipelineCoverageModulationStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(object), (api_dump.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));
+            dump_VkDrmFormatModifierPropertiesListEXT(api_dump, *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(object), (api_dump.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));
+            dump_VkImageDrmFormatModifierListCreateInfoEXT(api_dump, *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkImageDrmFormatModifierExplicitCreateInfoEXT(api_dump, *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkImageDrmFormatModifierPropertiesEXT(api_dump, *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(object), (api_dump.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));
+            dump_VkDrmFormatModifierPropertiesList2EXT(api_dump, *reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(object), (api_dump.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));
+            dump_VkValidationCacheCreateInfoEXT(api_dump, *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkShaderModuleValidationCacheCreateInfoEXT(api_dump, *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPipelineViewportShadingRateImageStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShadingRateImageFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShadingRateImagePropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(object), (api_dump.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));
+            dump_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkRayTracingShaderGroupCreateInfoNV(api_dump, *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(object), (api_dump.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));
+            dump_VkRayTracingPipelineCreateInfoNV(api_dump, *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(object), (api_dump.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));
+            dump_VkGeometryTrianglesNV(api_dump, *reinterpret_cast<const VkGeometryTrianglesNV*>(object), (api_dump.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));
+            dump_VkGeometryAABBNV(api_dump, *reinterpret_cast<const VkGeometryAABBNV*>(object), (api_dump.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));
+            dump_VkGeometryNV(api_dump, *reinterpret_cast<const VkGeometryNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureInfoNV(api_dump, *reinterpret_cast<const VkAccelerationStructureInfoNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureCreateInfoNV(api_dump, *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(object), (api_dump.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));
+            dump_VkBindAccelerationStructureMemoryInfoNV(api_dump, *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(object), (api_dump.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));
+            dump_VkWriteDescriptorSetAccelerationStructureNV(api_dump, *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureMemoryRequirementsInfoNV(api_dump, *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(object), (api_dump.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));
+            dump_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageViewImageFormatInfoEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(object), (api_dump.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));
+            dump_VkFilterCubicImageViewImageFormatPropertiesEXT(api_dump, *reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*" : "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(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));
+            dump_VkImportMemoryHostPointerInfoEXT(api_dump, *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(object), (api_dump.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));
+            dump_VkMemoryHostPointerPropertiesEXT(api_dump, *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineCompilerControlCreateInfoAMD(api_dump, *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderCorePropertiesAMD(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(object), (api_dump.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));
+            dump_VkDeviceMemoryOverallocationCreateInfoAMD(api_dump, *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPresentFrameTokenGGP(api_dump, *reinterpret_cast<const VkPresentFrameTokenGGP*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMeshShaderFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMeshShaderPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderImageFootprintFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(object), (api_dump.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));
+            dump_VkPipelineViewportExclusiveScissorStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExclusiveScissorFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(object), (api_dump.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));
+            dump_VkQueueFamilyCheckpointPropertiesNV(api_dump, *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(object), (api_dump.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));
+            dump_VkCheckpointDataNV(api_dump, *reinterpret_cast<const VkCheckpointDataNV*>(object), (api_dump.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));
+            dump_VkQueueFamilyCheckpointProperties2NV(api_dump, *reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(object), (api_dump.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));
+            dump_VkCheckpointData2NV(api_dump, *reinterpret_cast<const VkCheckpointData2NV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentTimingFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPresentTimingSurfaceCapabilitiesEXT(api_dump, *reinterpret_cast<const VkPresentTimingSurfaceCapabilitiesEXT*>(object), (api_dump.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));
+            dump_VkSwapchainCalibratedTimestampInfoEXT(api_dump, *reinterpret_cast<const VkSwapchainCalibratedTimestampInfoEXT*>(object), (api_dump.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));
+            dump_VkSwapchainTimingPropertiesEXT(api_dump, *reinterpret_cast<const VkSwapchainTimingPropertiesEXT*>(object), (api_dump.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));
+            dump_VkSwapchainTimeDomainPropertiesEXT(api_dump, *reinterpret_cast<const VkSwapchainTimeDomainPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPastPresentationTimingInfoEXT(api_dump, *reinterpret_cast<const VkPastPresentationTimingInfoEXT*>(object), (api_dump.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));
+            dump_VkPastPresentationTimingEXT(api_dump, *reinterpret_cast<const VkPastPresentationTimingEXT*>(object), (api_dump.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));
+            dump_VkPastPresentationTimingPropertiesEXT(api_dump, *reinterpret_cast<const VkPastPresentationTimingPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPresentTimingInfoEXT(api_dump, *reinterpret_cast<const VkPresentTimingInfoEXT*>(object), (api_dump.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));
+            dump_VkPresentTimingsInfoEXT(api_dump, *reinterpret_cast<const VkPresentTimingsInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(object), (api_dump.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));
+            dump_VkInitializePerformanceApiInfoINTEL(api_dump, *reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>(object), (api_dump.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));
+            dump_VkQueryPoolPerformanceQueryCreateInfoINTEL(api_dump, *reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(object), (api_dump.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));
+            dump_VkPerformanceMarkerInfoINTEL(api_dump, *reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>(object), (api_dump.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));
+            dump_VkPerformanceStreamMarkerInfoINTEL(api_dump, *reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>(object), (api_dump.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));
+            dump_VkPerformanceOverrideInfoINTEL(api_dump, *reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>(object), (api_dump.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));
+            dump_VkPerformanceConfigurationAcquireInfoINTEL(api_dump, *reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePCIBusInfoPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(object), (api_dump.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));
+            dump_VkDisplayNativeHdrSurfaceCapabilitiesAMD(api_dump, *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(object), (api_dump.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));
+            dump_VkSwapchainDisplayNativeHdrCreateInfoAMD(api_dump, *reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(object), (api_dump.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));
+            dump_VkImagePipeSurfaceCreateInfoFUCHSIA(api_dump, *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkMetalSurfaceCreateInfoEXT(api_dump, *reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(object), (api_dump.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));
+            dump_VkRenderPassFragmentDensityMapCreateInfoEXT(api_dump, *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkRenderingFragmentDensityMapAttachmentInfoEXT(api_dump, *reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderCoreProperties2AMD(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCoherentMemoryFeaturesAMD(api_dump, *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMemoryBudgetPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMemoryPriorityFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(object), (api_dump.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));
+            dump_VkMemoryPriorityAllocateInfoEXT(api_dump, *reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(object), (api_dump.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));
+            dump_VkBufferDeviceAddressCreateInfoEXT(api_dump, *reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkValidationFeaturesEXT(api_dump, *reinterpret_cast<const VkValidationFeaturesEXT*>(object), (api_dump.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));
+            dump_VkCooperativeMatrixPropertiesNV(api_dump, *reinterpret_cast<const VkCooperativeMatrixPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrixFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrixPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCoverageReductionModeFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(object), (api_dump.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));
+            dump_VkPipelineCoverageReductionStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkFramebufferMixedSamplesCombinationNV(api_dump, *reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceProvokingVertexFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceProvokingVertexPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkSurfaceFullScreenExclusiveInfoEXT(api_dump, *reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(object), (api_dump.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));
+            dump_VkSurfaceCapabilitiesFullScreenExclusiveEXT(api_dump, *reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(object), (api_dump.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));
+            dump_VkSurfaceFullScreenExclusiveWin32InfoEXT(api_dump, *reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(object), (api_dump.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));
+            dump_VkHeadlessSurfaceCreateInfoEXT(api_dump, *reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(object), (api_dump.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));
+            dump_VkMemoryMapPlacedInfoEXT(api_dump, *reinterpret_cast<const VkMemoryMapPlacedInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(object), (api_dump.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));
+            dump_VkGraphicsShaderGroupCreateInfoNV(api_dump, *reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV*>(object), (api_dump.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));
+            dump_VkGraphicsPipelineShaderGroupsCreateInfoNV(api_dump, *reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(object), (api_dump.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));
+            dump_VkIndirectCommandsLayoutTokenNV(api_dump, *reinterpret_cast<const VkIndirectCommandsLayoutTokenNV*>(object), (api_dump.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));
+            dump_VkIndirectCommandsLayoutCreateInfoNV(api_dump, *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV*>(object), (api_dump.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));
+            dump_VkGeneratedCommandsInfoNV(api_dump, *reinterpret_cast<const VkGeneratedCommandsInfoNV*>(object), (api_dump.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));
+            dump_VkGeneratedCommandsMemoryRequirementsInfoNV(api_dump, *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(object), (api_dump.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));
+            dump_VkCommandBufferInheritanceViewportScissorInfoNV(api_dump, *reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(object), (api_dump.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));
+            dump_VkRenderPassTransformBeginInfoQCOM(api_dump, *reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(object), (api_dump.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));
+            dump_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(api_dump, *reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDepthBiasControlFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(object), (api_dump.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));
+            dump_VkDepthBiasInfoEXT(api_dump, *reinterpret_cast<const VkDepthBiasInfoEXT*>(object), (api_dump.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));
+            dump_VkDepthBiasRepresentationInfoEXT(api_dump, *reinterpret_cast<const VkDepthBiasRepresentationInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(object), (api_dump.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));
+            dump_VkDeviceMemoryReportCallbackDataEXT(api_dump, *reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT*>(object), (api_dump.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));
+            dump_VkDeviceDeviceMemoryReportCreateInfoEXT(api_dump, *reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCustomBorderColorPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCustomBorderColorFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentBarrierFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(object), (api_dump.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));
+            dump_VkSurfaceCapabilitiesPresentBarrierNV(api_dump, *reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(object), (api_dump.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));
+            dump_VkSwapchainPresentBarrierCreateInfoNV(api_dump, *reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(object), (api_dump.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));
+            dump_VkDeviceDiagnosticsConfigCreateInfoNV(api_dump, *reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkDeviceDiagnosticsConfigCreateInfoNV*" : "VkDeviceDiagnosticsConfigCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(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));
+            dump_VkCudaModuleCreateInfoNV(api_dump, *reinterpret_cast<const VkCudaModuleCreateInfoNV*>(object), (api_dump.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));
+            dump_VkCudaFunctionCreateInfoNV(api_dump, *reinterpret_cast<const VkCudaFunctionCreateInfoNV*>(object), (api_dump.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));
+            dump_VkCudaLaunchInfoNV(api_dump, *reinterpret_cast<const VkCudaLaunchInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTileShadingFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTileShadingPropertiesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM*>(object), (api_dump.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));
+            dump_VkRenderPassTileShadingCreateInfoQCOM(api_dump, *reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM*>(object), (api_dump.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));
+            dump_VkPerTileBeginInfoQCOM(api_dump, *reinterpret_cast<const VkPerTileBeginInfoQCOM*>(object), (api_dump.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));
+            dump_VkPerTileEndInfoQCOM(api_dump, *reinterpret_cast<const VkPerTileEndInfoQCOM*>(object), (api_dump.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));
+            dump_VkDispatchTileInfoQCOM(api_dump, *reinterpret_cast<const VkDispatchTileInfoQCOM*>(object), (api_dump.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));
+            dump_VkQueryLowLatencySupportNV(api_dump, *reinterpret_cast<const VkQueryLowLatencySupportNV*>(object), (api_dump.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));
+            dump_VkExportMetalObjectCreateInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalObjectsInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalObjectsInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalDeviceInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalCommandQueueInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalBufferInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalBufferInfoEXT*>(object), (api_dump.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));
+            dump_VkImportMetalBufferInfoEXT(api_dump, *reinterpret_cast<const VkImportMetalBufferInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalTextureInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalTextureInfoEXT*>(object), (api_dump.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));
+            dump_VkImportMetalTextureInfoEXT(api_dump, *reinterpret_cast<const VkImportMetalTextureInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalIOSurfaceInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(object), (api_dump.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));
+            dump_VkImportMetalIOSurfaceInfoEXT(api_dump, *reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(object), (api_dump.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));
+            dump_VkExportMetalSharedEventInfoEXT(api_dump, *reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(object), (api_dump.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));
+            dump_VkImportMetalSharedEventInfoEXT(api_dump, *reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorBufferPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferPropertiesEXT*" : "VkPhysicalDeviceDescriptorBufferPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(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));
+            dump_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*" : "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(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));
+            dump_VkPhysicalDeviceDescriptorBufferFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(object), (api_dump.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));
+            dump_VkDescriptorAddressInfoEXT(api_dump, *reinterpret_cast<const VkDescriptorAddressInfoEXT*>(object), (api_dump.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));
+            dump_VkDescriptorBufferBindingInfoEXT(api_dump, *reinterpret_cast<const VkDescriptorBufferBindingInfoEXT*>(object), (api_dump.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));
+            dump_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(api_dump, *reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(object), (api_dump.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));
+            dump_VkDescriptorGetInfoEXT(api_dump, *reinterpret_cast<const VkDescriptorGetInfoEXT*>(object), (api_dump.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));
+            dump_VkBufferCaptureDescriptorDataInfoEXT(api_dump, *reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT*>(object), (api_dump.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));
+            dump_VkImageCaptureDescriptorDataInfoEXT(api_dump, *reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT*>(object), (api_dump.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));
+            dump_VkImageViewCaptureDescriptorDataInfoEXT(api_dump, *reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT*>(object), (api_dump.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));
+            dump_VkSamplerCaptureDescriptorDataInfoEXT(api_dump, *reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT*>(object), (api_dump.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));
+            dump_VkOpaqueCaptureDescriptorDataCreateInfoEXT(api_dump, *reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT(api_dump, *reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkAccelerationStructureCaptureDescriptorDataInfoEXT*" : "VkAccelerationStructureCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(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));
+            dump_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(object), (api_dump.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));
+            dump_VkGraphicsPipelineLibraryCreateInfoEXT(api_dump, *reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(object), (api_dump.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));
+            dump_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(api_dump, *reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureGeometryMotionTrianglesDataNV(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureMotionInfoNV(api_dump, *reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(object), (api_dump.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));
+            dump_VkCopyCommandTransformInfoQCOM(api_dump, *reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageCompressionControlFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(object), (api_dump.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));
+            dump_VkImageCompressionControlEXT(api_dump, *reinterpret_cast<const VkImageCompressionControlEXT*>(object), (api_dump.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));
+            dump_VkImageCompressionPropertiesEXT(api_dump, *reinterpret_cast<const VkImageCompressionPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevice4444FormatsFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFaultFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(object), (api_dump.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));
+            dump_VkDeviceFaultCountsEXT(api_dump, *reinterpret_cast<const VkDeviceFaultCountsEXT*>(object), (api_dump.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));
+            dump_VkDeviceFaultInfoEXT(api_dump, *reinterpret_cast<const VkDeviceFaultInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(object), (api_dump.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));
+            dump_VkDirectFBSurfaceCreateInfoEXT(api_dump, *reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(object), (api_dump.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));
+            dump_VkMutableDescriptorTypeCreateInfoEXT(api_dump, *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(object), (api_dump.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));
+            dump_VkVertexInputBindingDescription2EXT(api_dump, *reinterpret_cast<const VkVertexInputBindingDescription2EXT*>(object), (api_dump.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));
+            dump_VkVertexInputAttributeDescription2EXT(api_dump, *reinterpret_cast<const VkVertexInputAttributeDescription2EXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDrmPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAddressBindingReportFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(object), (api_dump.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));
+            dump_VkDeviceAddressBindingCallbackDataEXT(api_dump, *reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDepthClipControlFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPipelineViewportDepthClipControlCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(object), (api_dump.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));
+            dump_VkImportMemoryZirconHandleInfoFUCHSIA(api_dump, *reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkMemoryZirconHandlePropertiesFUCHSIA(api_dump, *reinterpret_cast<const VkMemoryZirconHandlePropertiesFUCHSIA*>(object), (api_dump.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));
+            dump_VkMemoryGetZirconHandleInfoFUCHSIA(api_dump, *reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkImportSemaphoreZirconHandleInfoFUCHSIA(api_dump, *reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkSemaphoreGetZirconHandleInfoFUCHSIA(api_dump, *reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkBufferCollectionCreateInfoFUCHSIA(api_dump, *reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkImportMemoryBufferCollectionFUCHSIA(api_dump, *reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(object), (api_dump.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));
+            dump_VkBufferCollectionImageCreateInfoFUCHSIA(api_dump, *reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkBufferCollectionConstraintsInfoFUCHSIA(api_dump, *reinterpret_cast<const VkBufferCollectionConstraintsInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkBufferConstraintsInfoFUCHSIA(api_dump, *reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkBufferCollectionBufferCreateInfoFUCHSIA(api_dump, *reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkSysmemColorSpaceFUCHSIA(api_dump, *reinterpret_cast<const VkSysmemColorSpaceFUCHSIA*>(object), (api_dump.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));
+            dump_VkBufferCollectionPropertiesFUCHSIA(api_dump, *reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA*>(object), (api_dump.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));
+            dump_VkImageFormatConstraintsInfoFUCHSIA(api_dump, *reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkImageConstraintsInfoFUCHSIA(api_dump, *reinterpret_cast<const VkImageConstraintsInfoFUCHSIA*>(object), (api_dump.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));
+            dump_VkSubpassShadingPipelineCreateInfoHUAWEI(api_dump, *reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(object), (api_dump.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));
+            dump_VkMemoryGetRemoteAddressInfoNV(api_dump, *reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(object), (api_dump.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));
+            dump_VkPipelinePropertiesIdentifierEXT(api_dump, *reinterpret_cast<const VkPipelinePropertiesIdentifierEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelinePropertiesFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFrameBoundaryFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(object), (api_dump.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));
+            dump_VkFrameBoundaryEXT(api_dump, *reinterpret_cast<const VkFrameBoundaryEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(object), (api_dump.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));
+            dump_VkSubpassResolvePerformanceQueryEXT(api_dump, *reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(object), (api_dump.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));
+            dump_VkMultisampledRenderToSingleSampledInfoEXT(api_dump, *reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(object), (api_dump.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));
+            dump_VkScreenSurfaceCreateInfoQNX(api_dump, *reinterpret_cast<const VkScreenSurfaceCreateInfoQNX*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceColorWriteEnableFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPipelineColorWriteCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(api_dump, *reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(object), (api_dump.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));
+            dump_VkVideoEncodeRgbConversionCapabilitiesVALVE(api_dump, *reinterpret_cast<const VkVideoEncodeRgbConversionCapabilitiesVALVE*>(object), (api_dump.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));
+            dump_VkVideoEncodeProfileRgbConversionInfoVALVE(api_dump, *reinterpret_cast<const VkVideoEncodeProfileRgbConversionInfoVALVE*>(object), (api_dump.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));
+            dump_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(api_dump, *reinterpret_cast<const VkVideoEncodeSessionRgbConversionCreateInfoVALVE*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageViewMinLodFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(object), (api_dump.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));
+            dump_VkImageViewMinLodCreateInfoEXT(api_dump, *reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultiDrawFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultiDrawPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderTileImageFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderTileImagePropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(object), (api_dump.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));
+            dump_VkMicromapBuildInfoEXT(api_dump, *reinterpret_cast<const VkMicromapBuildInfoEXT*>(object), (api_dump.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));
+            dump_VkMicromapCreateInfoEXT(api_dump, *reinterpret_cast<const VkMicromapCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceOpacityMicromapFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceOpacityMicromapPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(object), (api_dump.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));
+            dump_VkMicromapVersionInfoEXT(api_dump, *reinterpret_cast<const VkMicromapVersionInfoEXT*>(object), (api_dump.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));
+            dump_VkCopyMicromapToMemoryInfoEXT(api_dump, *reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT*>(object), (api_dump.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));
+            dump_VkCopyMemoryToMicromapInfoEXT(api_dump, *reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT*>(object), (api_dump.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));
+            dump_VkCopyMicromapInfoEXT(api_dump, *reinterpret_cast<const VkCopyMicromapInfoEXT*>(object), (api_dump.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));
+            dump_VkMicromapBuildSizesInfoEXT(api_dump, *reinterpret_cast<const VkMicromapBuildSizesInfoEXT*>(object), (api_dump.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));
+            dump_VkAccelerationStructureTrianglesOpacityMicromapEXT(api_dump, *reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDisplacementMicromapFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDisplacementMicromapPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureTrianglesDisplacementMicromapNV(api_dump, *reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(object), (api_dump.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));
+            dump_VkSamplerBorderColorComponentMappingCreateInfoEXT(api_dump, *reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderCorePropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(object), (api_dump.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));
+            dump_VkDeviceQueueShaderCoreControlCreateInfoARM(api_dump, *reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSchedulingControlsFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSchedulingControlsPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceSchedulingControlsPropertiesARM*" : "VkPhysicalDeviceSchedulingControlsPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM*>(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));
+            dump_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(object), (api_dump.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));
+            dump_VkImageViewSlicedCreateInfoEXT(api_dump, *reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(object), (api_dump.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));
+            dump_VkDescriptorSetBindingReferenceVALVE(api_dump, *reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE*>(object), (api_dump.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));
+            dump_VkDescriptorSetLayoutHostMappingInfoVALVE(api_dump, *reinterpret_cast<const VkDescriptorSetLayoutHostMappingInfoVALVE*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRenderPassStripedFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRenderPassStripedPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM*>(object), (api_dump.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));
+            dump_VkRenderPassStripeInfoARM(api_dump, *reinterpret_cast<const VkRenderPassStripeInfoARM*>(object), (api_dump.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));
+            dump_VkRenderPassStripeBeginInfoARM(api_dump, *reinterpret_cast<const VkRenderPassStripeBeginInfoARM*>(object), (api_dump.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));
+            dump_VkRenderPassStripeSubmitInfoARM(api_dump, *reinterpret_cast<const VkRenderPassStripeSubmitInfoARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*>(object), (api_dump.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));
+            dump_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(api_dump, *reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMemoryDecompressionFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMemoryDecompressionPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(object), (api_dump.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));
+            dump_VkComputePipelineIndirectBufferInfoNV(api_dump, *reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV*>(object), (api_dump.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));
+            dump_VkPipelineIndirectDeviceAddressInfoNV(api_dump, *reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureGeometrySpheresDataNV(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(object), (api_dump.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));
+            dump_VkImageViewSampleWeightCreateInfoQCOM(api_dump, *reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageProcessingFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageProcessingPropertiesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(object), (api_dump.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));
+            dump_VkNativeBufferUsageOHOS(api_dump, *reinterpret_cast<const VkNativeBufferUsageOHOS*>(object), (api_dump.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));
+            dump_VkNativeBufferPropertiesOHOS(api_dump, *reinterpret_cast<const VkNativeBufferPropertiesOHOS*>(object), (api_dump.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));
+            dump_VkNativeBufferFormatPropertiesOHOS(api_dump, *reinterpret_cast<const VkNativeBufferFormatPropertiesOHOS*>(object), (api_dump.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));
+            dump_VkImportNativeBufferInfoOHOS(api_dump, *reinterpret_cast<const VkImportNativeBufferInfoOHOS*>(object), (api_dump.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));
+            dump_VkMemoryGetNativeBufferInfoOHOS(api_dump, *reinterpret_cast<const VkMemoryGetNativeBufferInfoOHOS*>(object), (api_dump.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));
+            dump_VkExternalFormatOHOS(api_dump, *reinterpret_cast<const VkExternalFormatOHOS*>(object), (api_dump.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));
+            dump_VkExternalMemoryAcquireUnmodifiedEXT(api_dump, *reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(object), (api_dump.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));
+            dump_VkRenderPassCreationControlEXT(api_dump, *reinterpret_cast<const VkRenderPassCreationControlEXT*>(object), (api_dump.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));
+            dump_VkRenderPassCreationFeedbackCreateInfoEXT(api_dump, *reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkRenderPassSubpassFeedbackCreateInfoEXT(api_dump, *reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkDirectDriverLoadingInfoLUNARG(api_dump, *reinterpret_cast<const VkDirectDriverLoadingInfoLUNARG*>(object), (api_dump.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));
+            dump_VkDirectDriverLoadingListLUNARG(api_dump, *reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(object), (api_dump.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));
+            dump_VkTensorDescriptionARM(api_dump, *reinterpret_cast<const VkTensorDescriptionARM*>(object), (api_dump.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));
+            dump_VkTensorCreateInfoARM(api_dump, *reinterpret_cast<const VkTensorCreateInfoARM*>(object), (api_dump.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));
+            dump_VkTensorMemoryRequirementsInfoARM(api_dump, *reinterpret_cast<const VkTensorMemoryRequirementsInfoARM*>(object), (api_dump.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));
+            dump_VkBindTensorMemoryInfoARM(api_dump, *reinterpret_cast<const VkBindTensorMemoryInfoARM*>(object), (api_dump.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));
+            dump_VkWriteDescriptorSetTensorARM(api_dump, *reinterpret_cast<const VkWriteDescriptorSetTensorARM*>(object), (api_dump.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));
+            dump_VkTensorFormatPropertiesARM(api_dump, *reinterpret_cast<const VkTensorFormatPropertiesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTensorPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM*>(object), (api_dump.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));
+            dump_VkTensorMemoryBarrierARM(api_dump, *reinterpret_cast<const VkTensorMemoryBarrierARM*>(object), (api_dump.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));
+            dump_VkTensorDependencyInfoARM(api_dump, *reinterpret_cast<const VkTensorDependencyInfoARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTensorFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(object), (api_dump.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));
+            dump_VkDeviceTensorMemoryRequirementsARM(api_dump, *reinterpret_cast<const VkDeviceTensorMemoryRequirementsARM*>(object), (api_dump.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));
+            dump_VkTensorCopyARM(api_dump, *reinterpret_cast<const VkTensorCopyARM*>(object), (api_dump.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));
+            dump_VkCopyTensorInfoARM(api_dump, *reinterpret_cast<const VkCopyTensorInfoARM*>(object), (api_dump.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));
+            dump_VkMemoryDedicatedAllocateInfoTensorARM(api_dump, *reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalTensorInfoARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalTensorInfoARM*>(object), (api_dump.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));
+            dump_VkExternalTensorPropertiesARM(api_dump, *reinterpret_cast<const VkExternalTensorPropertiesARM*>(object), (api_dump.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));
+            dump_VkExternalMemoryTensorCreateInfoARM(api_dump, *reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*>(object), (api_dump.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));
+            dump_VkDescriptorGetTensorInfoARM(api_dump, *reinterpret_cast<const VkDescriptorGetTensorInfoARM*>(object), (api_dump.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));
+            dump_VkTensorCaptureDescriptorDataInfoARM(api_dump, *reinterpret_cast<const VkTensorCaptureDescriptorDataInfoARM*>(object), (api_dump.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));
+            dump_VkTensorViewCaptureDescriptorDataInfoARM(api_dump, *reinterpret_cast<const VkTensorViewCaptureDescriptorDataInfoARM*>(object), (api_dump.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));
+            dump_VkFrameBoundaryTensorsARM(api_dump, *reinterpret_cast<const VkFrameBoundaryTensorsARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkShaderModuleIdentifierEXT(api_dump, *reinterpret_cast<const VkShaderModuleIdentifierEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceOpticalFlowFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceOpticalFlowPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(object), (api_dump.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));
+            dump_VkOpticalFlowImageFormatInfoNV(api_dump, *reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(object), (api_dump.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));
+            dump_VkOpticalFlowImageFormatPropertiesNV(api_dump, *reinterpret_cast<const VkOpticalFlowImageFormatPropertiesNV*>(object), (api_dump.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));
+            dump_VkOpticalFlowSessionCreateInfoNV(api_dump, *reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV*>(object), (api_dump.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));
+            dump_VkOpticalFlowSessionCreatePrivateDataInfoNV(api_dump, *reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(object), (api_dump.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));
+            dump_VkOpticalFlowExecuteInfoNV(api_dump, *reinterpret_cast<const VkOpticalFlowExecuteInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLegacyDitheringFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(object), (api_dump.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));
+            dump_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(api_dump, *reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAntiLagFeaturesAMD(api_dump, *reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(object), (api_dump.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));
+            dump_VkAntiLagPresentationInfoAMD(api_dump, *reinterpret_cast<const VkAntiLagPresentationInfoAMD*>(object), (api_dump.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));
+            dump_VkAntiLagDataAMD(api_dump, *reinterpret_cast<const VkAntiLagDataAMD*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(api_dump, *reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(object), (api_dump.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));
+            dump_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(api_dump, *reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderObjectFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderObjectPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(object), (api_dump.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));
+            dump_VkShaderCreateInfoEXT(api_dump, *reinterpret_cast<const VkShaderCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTilePropertiesFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkTilePropertiesQCOM(api_dump, *reinterpret_cast<const VkTilePropertiesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAmigoProfilingFeaturesSEC(api_dump, *reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(object), (api_dump.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));
+            dump_VkAmigoProfilingSubmitInfoSEC(api_dump, *reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeVectorPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeVectorFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(object), (api_dump.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));
+            dump_VkCooperativeVectorPropertiesNV(api_dump, *reinterpret_cast<const VkCooperativeVectorPropertiesNV*>(object), (api_dump.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));
+            dump_VkConvertCooperativeVectorMatrixInfoNV(api_dump, *reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*>(object), (api_dump.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));
+            dump_VkLayerSettingsCreateInfoEXT(api_dump, *reinterpret_cast<const VkLayerSettingsCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(object), (api_dump.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));
+            dump_VkLatencySleepModeInfoNV(api_dump, *reinterpret_cast<const VkLatencySleepModeInfoNV*>(object), (api_dump.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));
+            dump_VkLatencySleepInfoNV(api_dump, *reinterpret_cast<const VkLatencySleepInfoNV*>(object), (api_dump.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));
+            dump_VkSetLatencyMarkerInfoNV(api_dump, *reinterpret_cast<const VkSetLatencyMarkerInfoNV*>(object), (api_dump.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));
+            dump_VkLatencyTimingsFrameReportNV(api_dump, *reinterpret_cast<const VkLatencyTimingsFrameReportNV*>(object), (api_dump.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));
+            dump_VkGetLatencyMarkerInfoNV(api_dump, *reinterpret_cast<const VkGetLatencyMarkerInfoNV*>(object), (api_dump.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));
+            dump_VkLatencySubmissionPresentIdNV(api_dump, *reinterpret_cast<const VkLatencySubmissionPresentIdNV*>(object), (api_dump.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));
+            dump_VkSwapchainLatencyCreateInfoNV(api_dump, *reinterpret_cast<const VkSwapchainLatencyCreateInfoNV*>(object), (api_dump.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));
+            dump_VkOutOfBandQueueTypeInfoNV(api_dump, *reinterpret_cast<const VkOutOfBandQueueTypeInfoNV*>(object), (api_dump.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));
+            dump_VkLatencySurfaceCapabilitiesNV(api_dump, *reinterpret_cast<const VkLatencySurfaceCapabilitiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDataGraphFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineConstantARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineConstantARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineResourceInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineResourceInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineCompilerControlCreateInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineCompilerControlCreateInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineCreateInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineCreateInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineShaderModuleCreateInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineShaderModuleCreateInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineSessionCreateInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineSessionCreateInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineSessionBindPointRequirementARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineSessionMemoryRequirementsInfoARM*>(object), (api_dump.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));
+            dump_VkBindDataGraphPipelineSessionMemoryInfoARM(api_dump, *reinterpret_cast<const VkBindDataGraphPipelineSessionMemoryInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelinePropertyQueryResultARM(api_dump, *reinterpret_cast<const VkDataGraphPipelinePropertyQueryResultARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineIdentifierCreateInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineIdentifierCreateInfoARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineDispatchInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineDispatchInfoARM*>(object), (api_dump.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));
+            dump_VkQueueFamilyDataGraphPropertiesARM(api_dump, *reinterpret_cast<const VkQueueFamilyDataGraphPropertiesARM*>(object), (api_dump.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));
+            dump_VkDataGraphProcessingEngineCreateInfoARM(api_dump, *reinterpret_cast<const VkDataGraphProcessingEngineCreateInfoARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*>(object), (api_dump.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));
+            dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM(api_dump, *reinterpret_cast<const VkQueueFamilyDataGraphProcessingEnginePropertiesARM*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(api_dump, *reinterpret_cast<const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*" : "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*>(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));
+            dump_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(api_dump, *reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageProcessing2FeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageProcessing2PropertiesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(object), (api_dump.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));
+            dump_VkSamplerBlockMatchWindowCreateInfoQCOM(api_dump, *reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCubicWeightsFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkSamplerCubicWeightsCreateInfoQCOM(api_dump, *reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM*>(object), (api_dump.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));
+            dump_VkBlitImageCubicWeightsInfoQCOM(api_dump, *reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(api_dump, *reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCubicClampFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(object), (api_dump.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));
+            dump_VkScreenBufferPropertiesQNX(api_dump, *reinterpret_cast<const VkScreenBufferPropertiesQNX*>(object), (api_dump.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));
+            dump_VkScreenBufferFormatPropertiesQNX(api_dump, *reinterpret_cast<const VkScreenBufferFormatPropertiesQNX*>(object), (api_dump.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));
+            dump_VkImportScreenBufferInfoQNX(api_dump, *reinterpret_cast<const VkImportScreenBufferInfoQNX*>(object), (api_dump.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));
+            dump_VkExternalFormatQNX(api_dump, *reinterpret_cast<const VkExternalFormatQNX*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceLayeredDriverPropertiesMSFT(api_dump, *reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(object), (api_dump.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));
+            dump_VkTileMemoryRequirementsQCOM(api_dump, *reinterpret_cast<const VkTileMemoryRequirementsQCOM*>(object), (api_dump.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));
+            dump_VkTileMemoryBindInfoQCOM(api_dump, *reinterpret_cast<const VkTileMemoryBindInfoQCOM*>(object), (api_dump.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));
+            dump_VkTileMemorySizeInfoQCOM(api_dump, *reinterpret_cast<const VkTileMemorySizeInfoQCOM*>(object), (api_dump.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));
+            dump_VkDecompressMemoryInfoEXT(api_dump, *reinterpret_cast<const VkDecompressMemoryInfoEXT*>(object), (api_dump.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));
+            dump_VkDisplaySurfaceStereoCreateInfoNV(api_dump, *reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV*>(object), (api_dump.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));
+            dump_VkDisplayModeStereoPropertiesNV(api_dump, *reinterpret_cast<const VkDisplayModeStereoPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRawAccessChainsFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(object), (api_dump.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));
+            dump_VkExternalComputeQueueDeviceCreateInfoNV(api_dump, *reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV*>(object), (api_dump.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));
+            dump_VkExternalComputeQueueCreateInfoNV(api_dump, *reinterpret_cast<const VkExternalComputeQueueCreateInfoNV*>(object), (api_dump.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));
+            dump_VkExternalComputeQueueDataParamsNV(api_dump, *reinterpret_cast<const VkExternalComputeQueueDataParamsNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceExternalComputeQueuePropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*" : "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(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));
+            dump_VkPhysicalDeviceShaderFloat8FeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingValidationFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(object), (api_dump.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));
+            dump_VkClusterAccelerationStructureClustersBottomLevelInputNV(api_dump, *reinterpret_cast<const VkClusterAccelerationStructureClustersBottomLevelInputNV*>(object), (api_dump.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));
+            dump_VkClusterAccelerationStructureTriangleClusterInputNV(api_dump, *reinterpret_cast<const VkClusterAccelerationStructureTriangleClusterInputNV*>(object), (api_dump.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));
+            dump_VkClusterAccelerationStructureMoveObjectsInputNV(api_dump, *reinterpret_cast<const VkClusterAccelerationStructureMoveObjectsInputNV*>(object), (api_dump.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));
+            dump_VkClusterAccelerationStructureInputInfoNV(api_dump, *reinterpret_cast<const VkClusterAccelerationStructureInputInfoNV*>(object), (api_dump.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));
+            dump_VkClusterAccelerationStructureCommandsInfoNV(api_dump, *reinterpret_cast<const VkClusterAccelerationStructureCommandsInfoNV*>(object), (api_dump.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));
+            dump_VkAccelerationStructureBuildSizesInfoKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR*>(object), (api_dump.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));
+            dump_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(api_dump, *reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(object), (api_dump.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));
+            dump_VkPartitionedAccelerationStructureFlagsNV(api_dump, *reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV*>(object), (api_dump.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));
+            dump_VkWriteDescriptorSetPartitionedAccelerationStructureNV(api_dump, *reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(object), (api_dump.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));
+            dump_VkPartitionedAccelerationStructureInstancesInputNV(api_dump, *reinterpret_cast<const VkPartitionedAccelerationStructureInstancesInputNV*>(object), (api_dump.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));
+            dump_VkBuildPartitionedAccelerationStructureInfoNV(api_dump, *reinterpret_cast<const VkBuildPartitionedAccelerationStructureInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*>(object), (api_dump.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));
+            dump_VkGeneratedCommandsMemoryRequirementsInfoEXT(api_dump, *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT*>(object), (api_dump.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));
+            dump_VkIndirectExecutionSetPipelineInfoEXT(api_dump, *reinterpret_cast<const VkIndirectExecutionSetPipelineInfoEXT*>(object), (api_dump.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));
+            dump_VkIndirectExecutionSetShaderLayoutInfoEXT(api_dump, *reinterpret_cast<const VkIndirectExecutionSetShaderLayoutInfoEXT*>(object), (api_dump.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));
+            dump_VkIndirectExecutionSetShaderInfoEXT(api_dump, *reinterpret_cast<const VkIndirectExecutionSetShaderInfoEXT*>(object), (api_dump.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));
+            dump_VkIndirectExecutionSetCreateInfoEXT(api_dump, *reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkGeneratedCommandsInfoEXT(api_dump, *reinterpret_cast<const VkGeneratedCommandsInfoEXT*>(object), (api_dump.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));
+            dump_VkWriteIndirectExecutionSetPipelineEXT(api_dump, *reinterpret_cast<const VkWriteIndirectExecutionSetPipelineEXT*>(object), (api_dump.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));
+            dump_VkIndirectCommandsLayoutTokenEXT(api_dump, *reinterpret_cast<const VkIndirectCommandsLayoutTokenEXT*>(object), (api_dump.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));
+            dump_VkIndirectCommandsLayoutCreateInfoEXT(api_dump, *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkGeneratedCommandsPipelineInfoEXT(api_dump, *reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT*>(object), (api_dump.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));
+            dump_VkGeneratedCommandsShaderInfoEXT(api_dump, *reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT*>(object), (api_dump.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));
+            dump_VkWriteIndirectExecutionSetShaderEXT(api_dump, *reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(api_dump, *reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(object), (api_dump.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));
+            dump_VkImageAlignmentControlCreateInfoMESA(api_dump, *reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA*>(object), (api_dump.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));
+            dump_VkPushConstantBankInfoNV(api_dump, *reinterpret_cast<const VkPushConstantBankInfoNV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePushConstantBankFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePushConstantBankPropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePushConstantBankPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDepthClampControlFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPipelineViewportDepthClampControlCreateInfoEXT(api_dump, *reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkSurfaceCreateInfoOHOS(api_dump, *reinterpret_cast<const VkSurfaceCreateInfoOHOS*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceHdrVividFeaturesHUAWEI(api_dump, *reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(object), (api_dump.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));
+            dump_VkHdrVividDynamicMetadataHUAWEI(api_dump, *reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI*>(object), (api_dump.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));
+            dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(api_dump, *reinterpret_cast<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(object), (api_dump.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));
+            dump_VkImportMemoryMetalHandleInfoEXT(api_dump, *reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT*>(object), (api_dump.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));
+            dump_VkMemoryMetalHandlePropertiesEXT(api_dump, *reinterpret_cast<const VkMemoryMetalHandlePropertiesEXT*>(object), (api_dump.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));
+            dump_VkMemoryGetMetalHandleInfoEXT(api_dump, *reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePerformanceCountersByRegionFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePerformanceCountersByRegionPropertiesARM(api_dump, *reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM*>(object), (api_dump.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));
+            dump_VkPerformanceCounterARM(api_dump, *reinterpret_cast<const VkPerformanceCounterARM*>(object), (api_dump.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));
+            dump_VkPerformanceCounterDescriptionARM(api_dump, *reinterpret_cast<const VkPerformanceCounterDescriptionARM*>(object), (api_dump.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));
+            dump_VkRenderPassPerformanceCountersByRegionBeginInfoARM(api_dump, *reinterpret_cast<const VkRenderPassPerformanceCountersByRegionBeginInfoARM*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkRenderPassPerformanceCountersByRegionBeginInfoARM*" : "VkRenderPassPerformanceCountersByRegionBeginInfoARM"), "pNext", indents, reinterpret_cast<const VkRenderPassPerformanceCountersByRegionBeginInfoARM*>(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));
+            dump_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFormatPackFeaturesARM(api_dump, *reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE(api_dump, *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>(object), (api_dump.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));
+            dump_VkPipelineFragmentDensityMapLayeredCreateInfoVALVE(api_dump, *reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*" : "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE"), "pNext", indents, reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>(object));
             break;
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
 
         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));
+            dump_VkSetPresentConfigNV(api_dump, *reinterpret_cast<const VkSetPresentConfigNV*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePresentMeteringFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDevicePresentMeteringFeaturesNV*" : "VkPhysicalDevicePresentMeteringFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(object));
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         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));
+            dump_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShader64BitIndexingFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceCustomResolveFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(object), (api_dump.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));
+            dump_VkBeginCustomResolveInfoEXT(api_dump, *reinterpret_cast<const VkBeginCustomResolveInfoEXT*>(object), (api_dump.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));
+            dump_VkCustomResolveCreateInfoEXT(api_dump, *reinterpret_cast<const VkCustomResolveCreateInfoEXT*>(object), (api_dump.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));
+            dump_VkDataGraphPipelineBuiltinModelCreateInfoQCOM(api_dump, *reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceDataGraphModelFeaturesQCOM(api_dump, *reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphModelFeaturesQCOM*" : "VkPhysicalDeviceDataGraphModelFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(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));
+            dump_VkPhysicalDeviceShaderLongVectorFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderLongVectorPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(api_dump, *reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(object), (api_dump.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));
+            dump_VkComputeOccupancyPriorityParametersNV(api_dump, *reinterpret_cast<const VkComputeOccupancyPriorityParametersNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV(api_dump, *reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*" : "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(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));
+            dump_VkAccelerationStructureGeometryTrianglesDataKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureGeometryAabbsDataKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureGeometryInstancesDataKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureGeometryKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureGeometryKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureBuildGeometryInfoKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureCreateInfoKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkWriteDescriptorSetAccelerationStructureKHR(api_dump, *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAccelerationStructureFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceAccelerationStructurePropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureDeviceAddressInfoKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR*>(object), (api_dump.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));
+            dump_VkAccelerationStructureVersionInfoKHR(api_dump, *reinterpret_cast<const VkAccelerationStructureVersionInfoKHR*>(object), (api_dump.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));
+            dump_VkCopyAccelerationStructureToMemoryInfoKHR(api_dump, *reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR*>(object), (api_dump.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));
+            dump_VkCopyMemoryToAccelerationStructureInfoKHR(api_dump, *reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR*>(object), (api_dump.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));
+            dump_VkCopyAccelerationStructureInfoKHR(api_dump, *reinterpret_cast<const VkCopyAccelerationStructureInfoKHR*>(object), (api_dump.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));
+            dump_VkRayTracingShaderGroupCreateInfoKHR(api_dump, *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkRayTracingPipelineInterfaceCreateInfoKHR(api_dump, *reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkRayTracingPipelineCreateInfoKHR(api_dump, *reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceRayQueryFeaturesKHR(api_dump, *reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMeshShaderFeaturesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(object), (api_dump.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));
+            dump_VkPhysicalDeviceMeshShaderPropertiesEXT(api_dump, *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(object), (api_dump.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);
+                dump_pNext_trampoline(api_dump, reinterpret_cast<const void*>(base_struct.pNext), type_name, var_name, indents);
             } else {
-                dump_nullptr<Format>(settings, "const void*", "pNext", indents);
+                dump_nullptr(api_dump, "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);
+            dump_start(api_dump, OutputConstruct::value, "const void*", "pNext", indents);
+            dump_value(api_dump, "UNKNOWN (", (int64_t)(base_struct.sType), ")");
+            dump_end(api_dump, 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);
+void dump_params_vkCreateInstance(ApiDumpInstance& api_dump, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkInstanceCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkInstanceCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInstance, "VkInstance*", "pInstance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkInstance);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyInstance(ApiDumpInstance& api_dump, VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumeratePhysicalDevices(ApiDumpInstance& api_dump, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPhysicalDeviceCount, "uint32_t*", "pPhysicalDeviceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPhysicalDevices, *pPhysicalDeviceCount, "VkPhysicalDevice*", "pPhysicalDevices", "VkPhysicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDevice);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFeatures(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFeatures, "VkPhysicalDeviceFeatures*", "pFeatures", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFormatProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFormat(api_dump, format, "VkFormat", "format", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFormatProperties, "VkFormatProperties*", "pFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceImageFormatProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFormat(api_dump, format, "VkFormat", "format", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageType(api_dump, type, "VkImageType", "type", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageTiling(api_dump, tiling, "VkImageTiling", "tiling", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageUsageFlags(api_dump, usage, "VkImageUsageFlags", "usage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageCreateFlags(api_dump, flags, "VkImageCreateFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageFormatProperties, "VkImageFormatProperties*", "pImageFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkPhysicalDeviceProperties*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceQueueFamilyProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueFamilyPropertyCount, "uint32_t*", "pQueueFamilyPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pQueueFamilyProperties, *pQueueFamilyPropertyCount, "VkQueueFamilyProperties*", "pQueueFamilyProperties", "VkQueueFamilyProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceMemoryProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryProperties, "VkPhysicalDeviceMemoryProperties*", "pMemoryProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDevice(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDeviceCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDevice, "VkDevice*", "pDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDevice);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDevice(ApiDumpInstance& api_dump, VkDevice device, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumerateInstanceExtensionProperties(ApiDumpInstance& api_dump, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_char(api_dump, pLayerName, "const char*", "pLayerName", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkExtensionProperties*", "pProperties", "VkExtensionProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtensionProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumerateDeviceExtensionProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_char(api_dump, pLayerName, "const char*", "pLayerName", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkExtensionProperties*", "pProperties", "VkExtensionProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtensionProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumerateInstanceLayerProperties(ApiDumpInstance& api_dump, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkLayerProperties*", "pProperties", "VkLayerProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkLayerProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumerateDeviceLayerProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkLayerProperties*", "pProperties", "VkLayerProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkLayerProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceQueue(ApiDumpInstance& api_dump, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueIndex, "uint32_t", "queueIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueue, "VkQueue*", "pQueue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueue);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueSubmit(ApiDumpInstance& api_dump, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, submitCount, "uint32_t", "submitCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSubmits, submitCount, "const VkSubmitInfo*", "pSubmits", "const VkSubmitInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo);
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueWaitIdle(ApiDumpInstance& api_dump, VkQueue queue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDeviceWaitIdle(ApiDumpInstance& api_dump, VkDevice device) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAllocateMemory(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocateInfo, "const VkMemoryAllocateInfo*", "pAllocateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryAllocateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemory, "VkDeviceMemory*", "pMemory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemory);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkFreeMemory(ApiDumpInstance& api_dump, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkMapMemory(ApiDumpInstance& api_dump, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, size, "VkDeviceSize", "size", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkMemoryMapFlags(api_dump, flags, "VkMemoryMapFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void**>(api_dump, ppData, "void**", "ppData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUnmapMemory(ApiDumpInstance& api_dump, VkDevice device, VkDeviceMemory memory) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkFlushMappedMemoryRanges(ApiDumpInstance& api_dump, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, memoryRangeCount, "uint32_t", "memoryRangeCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMemoryRanges, memoryRangeCount, "const VkMappedMemoryRange*", "pMemoryRanges", "const VkMappedMemoryRange", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMappedMemoryRange);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkInvalidateMappedMemoryRanges(ApiDumpInstance& api_dump, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, memoryRangeCount, "uint32_t", "memoryRangeCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMemoryRanges, memoryRangeCount, "const VkMappedMemoryRange*", "pMemoryRanges", "const VkMappedMemoryRange", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMappedMemoryRange);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceMemoryCommitment(ApiDumpInstance& api_dump, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCommittedMemoryInBytes, "VkDeviceSize*", "pCommittedMemoryInBytes", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindBufferMemory(ApiDumpInstance& api_dump, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, memoryOffset, "VkDeviceSize", "memoryOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindImageMemory(ApiDumpInstance& api_dump, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, memoryOffset, "VkDeviceSize", "memoryOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferMemoryRequirements(ApiDumpInstance& api_dump, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageMemoryRequirements(ApiDumpInstance& api_dump, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSparseMemoryRequirements(ApiDumpInstance& api_dump, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSparseMemoryRequirementCount, "uint32_t*", "pSparseMemoryRequirementCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSparseMemoryRequirements, *pSparseMemoryRequirementCount, "VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFormat(api_dump, format, "VkFormat", "format", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageType(api_dump, type, "VkImageType", "type", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSampleCountFlagBits(api_dump, samples, "VkSampleCountFlagBits", "samples", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageUsageFlags(api_dump, usage, "VkImageUsageFlags", "usage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageTiling(api_dump, tiling, "VkImageTiling", "tiling", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkSparseImageFormatProperties*", "pProperties", "VkSparseImageFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueBindSparse(ApiDumpInstance& api_dump, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfo, bindInfoCount, "const VkBindSparseInfo*", "pBindInfo", "const VkBindSparseInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindSparseInfo);
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateFence(ApiDumpInstance& api_dump, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkFenceCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFence, "VkFence*", "pFence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFence);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyFence(ApiDumpInstance& api_dump, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetFences(ApiDumpInstance& api_dump, VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, fenceCount, "uint32_t", "fenceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pFences, fenceCount, "const VkFence*", "pFences", "const VkFence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFence);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetFenceStatus(ApiDumpInstance& api_dump, VkDevice device, VkFence fence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWaitForFences(ApiDumpInstance& api_dump, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, fenceCount, "uint32_t", "fenceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pFences, fenceCount, "const VkFence*", "pFences", "const VkFence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFence);
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, waitAll, "VkBool32", "waitAll", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, timeout, "uint64_t", "timeout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateSemaphore(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkSemaphoreCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSemaphore, "VkSemaphore*", "pSemaphore", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphore);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroySemaphore(ApiDumpInstance& api_dump, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSemaphore(api_dump, semaphore, "VkSemaphore", "semaphore", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateQueryPool(ApiDumpInstance& api_dump, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkQueryPoolCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPoolCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueryPool, "VkQueryPool*", "pQueryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPool);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyQueryPool(ApiDumpInstance& api_dump, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetQueryPoolResults(ApiDumpInstance& api_dump, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queryCount, "uint32_t", "queryCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, stride, "VkDeviceSize", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryResultFlags(api_dump, flags, "VkQueryResultFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateBuffer(ApiDumpInstance& api_dump, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkBufferCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBuffer, "VkBuffer*", "pBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyBuffer(ApiDumpInstance& api_dump, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateImage(ApiDumpInstance& api_dump, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkImageCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImage, "VkImage*", "pImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImage);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyImage(ApiDumpInstance& api_dump, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSubresourceLayout(ApiDumpInstance& api_dump, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubresource, "const VkImageSubresource*", "pSubresource", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayout, "VkSubresourceLayout*", "pLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateImageView(ApiDumpInstance& api_dump, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkImageViewCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pView, "VkImageView*", "pView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageView);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyImageView(ApiDumpInstance& api_dump, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageView(api_dump, imageView, "VkImageView", "imageView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateCommandPool(ApiDumpInstance& api_dump, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkCommandPoolCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandPoolCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCommandPool, "VkCommandPool*", "pCommandPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandPool);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyCommandPool(ApiDumpInstance& api_dump, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPool(api_dump, commandPool, "VkCommandPool", "commandPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetCommandPool(ApiDumpInstance& api_dump, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPool(api_dump, commandPool, "VkCommandPool", "commandPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPoolResetFlags(api_dump, flags, "VkCommandPoolResetFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAllocateCommandBuffers(ApiDumpInstance& api_dump, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocateInfo, "const VkCommandBufferAllocateInfo*", "pAllocateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBufferAllocateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCommandBuffers, pAllocateInfo->commandBufferCount, "VkCommandBuffer*", "pCommandBuffers", "VkCommandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkFreeCommandBuffers(ApiDumpInstance& api_dump, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPool(api_dump, commandPool, "VkCommandPool", "commandPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, commandBufferCount, "uint32_t", "commandBufferCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCommandBuffers, commandBufferCount, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBeginCommandBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        api_dump.setCmdBuffer(commandBuffer);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBeginInfo, "const VkCommandBufferBeginInfo*", "pBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBufferBeginInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEndCommandBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetCommandBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandBufferResetFlags(api_dump, flags, "VkCommandBufferResetFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, srcBuffer, "VkBuffer", "srcBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, regionCount, "uint32_t", "regionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRegions, regionCount, "const VkBufferCopy*", "pRegions", "const VkBufferCopy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCopy);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyImage(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, srcImage, "VkImage", "srcImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, srcImageLayout, "VkImageLayout", "srcImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, dstImage, "VkImage", "dstImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, dstImageLayout, "VkImageLayout", "dstImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, regionCount, "uint32_t", "regionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRegions, regionCount, "const VkImageCopy*", "pRegions", "const VkImageCopy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCopy);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyBufferToImage(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, srcBuffer, "VkBuffer", "srcBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, dstImage, "VkImage", "dstImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, dstImageLayout, "VkImageLayout", "dstImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, regionCount, "uint32_t", "regionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRegions, regionCount, "const VkBufferImageCopy*", "pRegions", "const VkBufferImageCopy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferImageCopy);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyImageToBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, srcImage, "VkImage", "srcImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, srcImageLayout, "VkImageLayout", "srcImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, regionCount, "uint32_t", "regionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRegions, regionCount, "const VkBufferImageCopy*", "pRegions", "const VkBufferImageCopy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferImageCopy);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdUpdateBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, dstOffset, "VkDeviceSize", "dstOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, dataSize, "VkDeviceSize", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pData, "const void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdFillBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, dstOffset, "VkDeviceSize", "dstOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, size, "VkDeviceSize", "size", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, data, "uint32_t", "data", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPipelineBarrier(ApiDumpInstance& api_dump, 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) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags(api_dump, srcStageMask, "VkPipelineStageFlags", "srcStageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags(api_dump, dstStageMask, "VkPipelineStageFlags", "dstStageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDependencyFlags(api_dump, dependencyFlags, "VkDependencyFlags", "dependencyFlags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, memoryBarrierCount, "uint32_t", "memoryBarrierCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMemoryBarriers, memoryBarrierCount, "const VkMemoryBarrier*", "pMemoryBarriers", "const VkMemoryBarrier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryBarrier);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bufferMemoryBarrierCount, "uint32_t", "bufferMemoryBarrierCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBufferMemoryBarriers, bufferMemoryBarrierCount, "const VkBufferMemoryBarrier*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryBarrier);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, imageMemoryBarrierCount, "uint32_t", "imageMemoryBarrierCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pImageMemoryBarriers, imageMemoryBarrierCount, "const VkImageMemoryBarrier*", "pImageMemoryBarriers", "const VkImageMemoryBarrier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryBarrier);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginQuery(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryControlFlags(api_dump, flags, "VkQueryControlFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndQuery(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResetQueryPool(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queryCount, "uint32_t", "queryCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteTimestamp(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlagBits(api_dump, pipelineStage, "VkPipelineStageFlagBits", "pipelineStage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyQueryPoolResults(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queryCount, "uint32_t", "queryCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, dstOffset, "VkDeviceSize", "dstOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, stride, "VkDeviceSize", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryResultFlags(api_dump, flags, "VkQueryResultFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdExecuteCommands(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, commandBufferCount, "uint32_t", "commandBufferCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCommandBuffers, commandBufferCount, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateEvent(ApiDumpInstance& api_dump, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkEventCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkEventCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pEvent, "VkEvent*", "pEvent", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyEvent(ApiDumpInstance& api_dump, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetEventStatus(ApiDumpInstance& api_dump, VkDevice device, VkEvent event) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetEvent(ApiDumpInstance& api_dump, VkDevice device, VkEvent event) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetEvent(ApiDumpInstance& api_dump, VkDevice device, VkEvent event) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateBufferView(ApiDumpInstance& api_dump, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkBufferViewCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferViewCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pView, "VkBufferView*", "pView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferView);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyBufferView(ApiDumpInstance& api_dump, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBufferView(api_dump, bufferView, "VkBufferView", "bufferView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateShaderModule(ApiDumpInstance& api_dump, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkShaderModuleCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pShaderModule, "VkShaderModule*", "pShaderModule", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModule);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyShaderModule(ApiDumpInstance& api_dump, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderModule(api_dump, shaderModule, "VkShaderModule", "shaderModule", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreatePipelineCache(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkPipelineCacheCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCacheCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineCache, "VkPipelineCache*", "pPipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCache);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyPipelineCache(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineCacheData(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDataSize, "size_t*", "pDataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkMergePipelineCaches(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, dstCache, "VkPipelineCache", "dstCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, srcCacheCount, "uint32_t", "srcCacheCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSrcCaches, srcCacheCount, "const VkPipelineCache*", "pSrcCaches", "const VkPipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCache);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateComputePipelines(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkComputePipelineCreateInfo*", "pCreateInfos", "const VkComputePipelineCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkComputePipelineCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPipelines, createInfoCount, "VkPipeline*", "pPipelines", "VkPipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyPipeline(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreatePipelineLayout(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkPipelineLayoutCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineLayoutCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineLayout, "VkPipelineLayout*", "pPipelineLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineLayout);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyPipelineLayout(ApiDumpInstance& api_dump, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, pipelineLayout, "VkPipelineLayout", "pipelineLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateSampler(ApiDumpInstance& api_dump, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkSamplerCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSampler, "VkSampler*", "pSampler", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSampler);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroySampler(ApiDumpInstance& api_dump, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSampler(api_dump, sampler, "VkSampler", "sampler", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDescriptorSetLayout(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSetLayout, "VkDescriptorSetLayout*", "pSetLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayout);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDescriptorSetLayout(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorSetLayout(api_dump, descriptorSetLayout, "VkDescriptorSetLayout", "descriptorSetLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDescriptorPool(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDescriptorPoolCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorPoolCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDescriptorPool, "VkDescriptorPool*", "pDescriptorPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorPool);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDescriptorPool(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorPool(api_dump, descriptorPool, "VkDescriptorPool", "descriptorPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetDescriptorPool(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorPool(api_dump, descriptorPool, "VkDescriptorPool", "descriptorPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorPoolResetFlags(api_dump, flags, "VkDescriptorPoolResetFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAllocateDescriptorSets(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocateInfo, "const VkDescriptorSetAllocateInfo*", "pAllocateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetAllocateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorSets, pAllocateInfo->descriptorSetCount, "VkDescriptorSet*", "pDescriptorSets", "VkDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkFreeDescriptorSets(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorPool(api_dump, descriptorPool, "VkDescriptorPool", "descriptorPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, descriptorSetCount, "uint32_t", "descriptorSetCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorSets, descriptorSetCount, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUpdateDescriptorSets(ApiDumpInstance& api_dump, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, descriptorWriteCount, "uint32_t", "descriptorWriteCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorWrites, descriptorWriteCount, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, descriptorCopyCount, "uint32_t", "descriptorCopyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorCopies, descriptorCopyCount, "const VkCopyDescriptorSet*", "pDescriptorCopies", "const VkCopyDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyDescriptorSet);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindPipeline(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindDescriptorSets(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstSet, "uint32_t", "firstSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, descriptorSetCount, "uint32_t", "descriptorSetCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorSets, descriptorSetCount, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, dynamicOffsetCount, "uint32_t", "dynamicOffsetCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDynamicOffsets, dynamicOffsetCount, "const uint32_t*", "pDynamicOffsets", "const uint32_t", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const uint32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdClearColorImage(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, imageLayout, "VkImageLayout", "imageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pColor, "const VkClearColorValue*", "pColor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkClearColorValue);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, rangeCount, "uint32_t", "rangeCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRanges, rangeCount, "const VkImageSubresourceRange*", "pRanges", "const VkImageSubresourceRange", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceRange);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatch(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountX, "uint32_t", "groupCountX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountY, "uint32_t", "groupCountY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountZ, "uint32_t", "groupCountZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchIndirect(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetEvent(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags(api_dump, stageMask, "VkPipelineStageFlags", "stageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResetEvent(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags(api_dump, stageMask, "VkPipelineStageFlags", "stageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWaitEvents(ApiDumpInstance& api_dump, 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) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, eventCount, "uint32_t", "eventCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pEvents, eventCount, "const VkEvent*", "pEvents", "const VkEvent", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent);
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags(api_dump, srcStageMask, "VkPipelineStageFlags", "srcStageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags(api_dump, dstStageMask, "VkPipelineStageFlags", "dstStageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, memoryBarrierCount, "uint32_t", "memoryBarrierCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMemoryBarriers, memoryBarrierCount, "const VkMemoryBarrier*", "pMemoryBarriers", "const VkMemoryBarrier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryBarrier);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bufferMemoryBarrierCount, "uint32_t", "bufferMemoryBarrierCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBufferMemoryBarriers, bufferMemoryBarrierCount, "const VkBufferMemoryBarrier*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryBarrier);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, imageMemoryBarrierCount, "uint32_t", "imageMemoryBarrierCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pImageMemoryBarriers, imageMemoryBarrierCount, "const VkImageMemoryBarrier*", "pImageMemoryBarriers", "const VkImageMemoryBarrier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryBarrier);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushConstants(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderStageFlags(api_dump, stageFlags, "VkShaderStageFlags", "stageFlags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, offset, "uint32_t", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, size, "uint32_t", "size", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pValues, "const void*", "pValues", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateGraphicsPipelines(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkGraphicsPipelineCreateInfo*", "pCreateInfos", "const VkGraphicsPipelineCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGraphicsPipelineCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPipelines, createInfoCount, "VkPipeline*", "pPipelines", "VkPipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateFramebuffer(ApiDumpInstance& api_dump, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkFramebufferCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebufferCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFramebuffer, "VkFramebuffer*", "pFramebuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebuffer);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyFramebuffer(ApiDumpInstance& api_dump, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFramebuffer(api_dump, framebuffer, "VkFramebuffer", "framebuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateRenderPass(ApiDumpInstance& api_dump, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkRenderPassCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderPass, "VkRenderPass*", "pRenderPass", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyRenderPass(ApiDumpInstance& api_dump, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkRenderPass(api_dump, renderPass, "VkRenderPass", "renderPass", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRenderAreaGranularity(ApiDumpInstance& api_dump, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkRenderPass(api_dump, renderPass, "VkRenderPass", "renderPass", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGranularity, "VkExtent2D*", "pGranularity", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewport(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstViewport, "uint32_t", "firstViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, viewportCount, "uint32_t", "viewportCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pViewports, viewportCount, "const VkViewport*", "pViewports", "const VkViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetScissor(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstScissor, "uint32_t", "firstScissor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, scissorCount, "uint32_t", "scissorCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pScissors, scissorCount, "const VkRect2D*", "pScissors", "const VkRect2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLineWidth(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, float lineWidth) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, lineWidth, "float", "lineWidth", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBias(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, depthBiasConstantFactor, "float", "depthBiasConstantFactor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, depthBiasClamp, "float", "depthBiasClamp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, depthBiasSlopeFactor, "float", "depthBiasSlopeFactor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetBlendConstants(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, blendConstants, 4, "const float[4]", "blendConstants", "const float", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const float>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBounds(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, minDepthBounds, "float", "minDepthBounds", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, maxDepthBounds, "float", "maxDepthBounds", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilCompareMask(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilFaceFlags(api_dump, faceMask, "VkStencilFaceFlags", "faceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, compareMask, "uint32_t", "compareMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilWriteMask(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilFaceFlags(api_dump, faceMask, "VkStencilFaceFlags", "faceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, writeMask, "uint32_t", "writeMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilReference(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilFaceFlags(api_dump, faceMask, "VkStencilFaceFlags", "faceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, reference, "uint32_t", "reference", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindIndexBuffer(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndexType(api_dump, indexType, "VkIndexType", "indexType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindVertexBuffers(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstBinding, "uint32_t", "firstBinding", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindingCount, "uint32_t", "bindingCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBuffers, bindingCount, "const VkBuffer*", "pBuffers", "const VkBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pOffsets, bindingCount, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDraw(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, vertexCount, "uint32_t", "vertexCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, instanceCount, "uint32_t", "instanceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstVertex, "uint32_t", "firstVertex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstInstance, "uint32_t", "firstInstance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndexed(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, indexCount, "uint32_t", "indexCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, instanceCount, "uint32_t", "instanceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstIndex, "uint32_t", "firstIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<int32_t>(api_dump, vertexOffset, "int32_t", "vertexOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstInstance, "uint32_t", "firstInstance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndirect(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, drawCount, "uint32_t", "drawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndexedIndirect(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, drawCount, "uint32_t", "drawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBlitImage(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, srcImage, "VkImage", "srcImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, srcImageLayout, "VkImageLayout", "srcImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, dstImage, "VkImage", "dstImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, dstImageLayout, "VkImageLayout", "dstImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, regionCount, "uint32_t", "regionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRegions, regionCount, "const VkImageBlit*", "pRegions", "const VkImageBlit", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageBlit);
+        dump_separate_members(api_dump);
+        dump_VkFilter(api_dump, filter, "VkFilter", "filter", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdClearDepthStencilImage(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, imageLayout, "VkImageLayout", "imageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDepthStencil, "const VkClearDepthStencilValue*", "pDepthStencil", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkClearDepthStencilValue);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, rangeCount, "uint32_t", "rangeCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRanges, rangeCount, "const VkImageSubresourceRange*", "pRanges", "const VkImageSubresourceRange", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceRange);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdClearAttachments(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, attachmentCount, "uint32_t", "attachmentCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pAttachments, attachmentCount, "const VkClearAttachment*", "pAttachments", "const VkClearAttachment", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkClearAttachment);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, rectCount, "uint32_t", "rectCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRects, rectCount, "const VkClearRect*", "pRects", "const VkClearRect", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkClearRect);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResolveImage(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, srcImage, "VkImage", "srcImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, srcImageLayout, "VkImageLayout", "srcImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, dstImage, "VkImage", "dstImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, dstImageLayout, "VkImageLayout", "dstImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, regionCount, "uint32_t", "regionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRegions, regionCount, "const VkImageResolve*", "pRegions", "const VkImageResolve", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageResolve);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginRenderPass(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderPassBegin, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo);
+        dump_separate_members(api_dump);
+        dump_VkSubpassContents(api_dump, contents, "VkSubpassContents", "contents", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdNextSubpass(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSubpassContents(api_dump, contents, "VkSubpassContents", "contents", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRenderPass(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindBufferMemory2(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindBufferMemoryInfo*", "pBindInfos", "const VkBindBufferMemoryInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindBufferMemoryInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindImageMemory2(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindImageMemoryInfo*", "pBindInfos", "const VkBindImageMemoryInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindImageMemoryInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceGroupPeerMemoryFeatures(ApiDumpInstance& api_dump, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, heapIndex, "uint32_t", "heapIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, localDeviceIndex, "uint32_t", "localDeviceIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, remoteDeviceIndex, "uint32_t", "remoteDeviceIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPeerMemoryFeatures, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPeerMemoryFeatureFlags);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDeviceMask(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, deviceMask, "uint32_t", "deviceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumeratePhysicalDeviceGroups(ApiDumpInstance& api_dump, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPhysicalDeviceGroupCount, "uint32_t*", "pPhysicalDeviceGroupCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, "VkPhysicalDeviceGroupProperties*", "pPhysicalDeviceGroupProperties", "VkPhysicalDeviceGroupProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceGroupProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageMemoryRequirements2(ApiDumpInstance& api_dump, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageMemoryRequirementsInfo2*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryRequirementsInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferMemoryRequirements2(ApiDumpInstance& api_dump, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferMemoryRequirementsInfo2*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryRequirementsInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSparseMemoryRequirements2(ApiDumpInstance& api_dump, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSparseMemoryRequirementsInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSparseMemoryRequirementCount, "uint32_t*", "pSparseMemoryRequirementCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSparseMemoryRequirements, *pSparseMemoryRequirementCount, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFeatures2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFeatures, "VkPhysicalDeviceFeatures2*", "pFeatures", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceProperties2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkPhysicalDeviceProperties2*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFormatProperties2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFormat(api_dump, format, "VkFormat", "format", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFormatProperties, "VkFormatProperties2*", "pFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceImageFormatProperties2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageFormatInfo, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceImageFormatInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageFormatProperties, "VkImageFormatProperties2*", "pImageFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueFamilyPropertyCount, "uint32_t*", "pQueueFamilyPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pQueueFamilyProperties, *pQueueFamilyPropertyCount, "VkQueueFamilyProperties2*", "pQueueFamilyProperties", "VkQueueFamilyProperties2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceMemoryProperties2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryProperties, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFormatInfo, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSparseImageFormatInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkSparseImageFormatProperties2*", "pProperties", "VkSparseImageFormatProperties2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkTrimCommandPool(ApiDumpInstance& api_dump, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPool(api_dump, commandPool, "VkCommandPool", "commandPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPoolTrimFlags(api_dump, flags, "VkCommandPoolTrimFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceQueue2(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueInfo, "const VkDeviceQueueInfo2*", "pQueueInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceQueueInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueue, "VkQueue*", "pQueue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueue);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalBufferProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalBufferInfo, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalBufferInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalBufferProperties, "VkExternalBufferProperties*", "pExternalBufferProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalBufferProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalFenceProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalFenceInfo, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalFenceInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalFenceProperties, "VkExternalFenceProperties*", "pExternalFenceProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalFenceProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalSemaphoreInfo, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalSemaphoreInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalSemaphoreProperties, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalSemaphoreProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchBase(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, baseGroupX, "uint32_t", "baseGroupX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, baseGroupY, "uint32_t", "baseGroupY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, baseGroupZ, "uint32_t", "baseGroupZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountX, "uint32_t", "groupCountX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountY, "uint32_t", "groupCountY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountZ, "uint32_t", "groupCountZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDescriptorUpdateTemplate(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplateCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDescriptorUpdateTemplate, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplate);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDescriptorUpdateTemplate(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorUpdateTemplate(api_dump, descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUpdateDescriptorSetWithTemplate(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorSet(api_dump, descriptorSet, "VkDescriptorSet", "descriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorUpdateTemplate(api_dump, descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pData, "const void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDescriptorSetLayoutSupport(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSupport, "VkDescriptorSetLayoutSupport*", "pSupport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutSupport);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateSamplerYcbcrConversion(ApiDumpInstance& api_dump, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversionCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pYcbcrConversion, "VkSamplerYcbcrConversion*", "pYcbcrConversion", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversion);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroySamplerYcbcrConversion(ApiDumpInstance& api_dump, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSamplerYcbcrConversion(api_dump, ycbcrConversion, "VkSamplerYcbcrConversion", "ycbcrConversion", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetQueryPool(ApiDumpInstance& api_dump, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queryCount, "uint32_t", "queryCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSemaphoreCounterValue(ApiDumpInstance& api_dump, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSemaphore(api_dump, semaphore, "VkSemaphore", "semaphore", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pValue, "uint64_t*", "pValue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWaitSemaphores(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pWaitInfo, "const VkSemaphoreWaitInfo*", "pWaitInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreWaitInfo);
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, timeout, "uint64_t", "timeout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSignalSemaphore(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSignalInfo, "const VkSemaphoreSignalInfo*", "pSignalInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreSignalInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferDeviceAddress(ApiDumpInstance& api_dump, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferDeviceAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferOpaqueCaptureAddress(ApiDumpInstance& api_dump, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferDeviceAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemoryOpaqueCaptureAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndirectCount(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndexedIndirectCount(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateRenderPass2(ApiDumpInstance& api_dump, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkRenderPassCreateInfo2*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderPass, "VkRenderPass*", "pRenderPass", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginRenderPass2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderPassBegin, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassBeginInfo, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdNextSubpass2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassBeginInfo, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassEndInfo, "const VkSubpassEndInfo*", "pSubpassEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRenderPass2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassEndInfo, "const VkSubpassEndInfo*", "pSubpassEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceToolProperties(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pToolCount, "uint32_t*", "pToolCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pToolProperties, *pToolCount, "VkPhysicalDeviceToolProperties*", "pToolProperties", "VkPhysicalDeviceToolProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceToolProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreatePrivateDataSlot(ApiDumpInstance& api_dump, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlotCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPrivateDataSlot, "VkPrivateDataSlot*", "pPrivateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlot);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyPrivateDataSlot(ApiDumpInstance& api_dump, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrivateDataSlot(api_dump, privateDataSlot, "VkPrivateDataSlot", "privateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetPrivateData(ApiDumpInstance& api_dump, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkObjectType(api_dump, objectType, "VkObjectType", "objectType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_uint64_t_as_pointer(api_dump, objectHandle, "uint64_t", "objectHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrivateDataSlot(api_dump, privateDataSlot, "VkPrivateDataSlot", "privateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, data, "uint64_t", "data", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPrivateData(ApiDumpInstance& api_dump, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkObjectType(api_dump, objectType, "VkObjectType", "objectType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_uint64_t_as_pointer(api_dump, objectHandle, "uint64_t", "objectHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrivateDataSlot(api_dump, privateDataSlot, "VkPrivateDataSlot", "privateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pData, "uint64_t*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPipelineBarrier2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDependencyInfo, "const VkDependencyInfo*", "pDependencyInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteTimestamp2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags2(api_dump, stage, "VkPipelineStageFlags2", "stage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueSubmit2(ApiDumpInstance& api_dump, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, submitCount, "uint32_t", "submitCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSubmits, submitCount, "const VkSubmitInfo2*", "pSubmits", "const VkSubmitInfo2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo2);
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyBuffer2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyBufferInfo, "const VkCopyBufferInfo2*", "pCopyBufferInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyImage2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageInfo, "const VkCopyImageInfo2*", "pCopyImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyBufferToImage2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyBufferToImageInfo, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferToImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyImageToBuffer2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageToBufferInfo, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToBufferInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceBufferMemoryRequirements(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceBufferMemoryRequirements*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceBufferMemoryRequirements);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceImageMemoryRequirements(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceImageMemoryRequirements*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceImageSparseMemoryRequirements(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceImageMemoryRequirements*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSparseMemoryRequirementCount, "uint32_t*", "pSparseMemoryRequirementCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSparseMemoryRequirements, *pSparseMemoryRequirementCount, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetEvent2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDependencyInfo, "const VkDependencyInfo*", "pDependencyInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResetEvent2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags2(api_dump, stageMask, "VkPipelineStageFlags2", "stageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWaitEvents2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, eventCount, "uint32_t", "eventCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pEvents, eventCount, "const VkEvent*", "pEvents", "const VkEvent", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDependencyInfos, eventCount, "const VkDependencyInfo*", "pDependencyInfos", "const VkDependencyInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBlitImage2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBlitImageInfo, "const VkBlitImageInfo2*", "pBlitImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBlitImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResolveImage2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pResolveImageInfo, "const VkResolveImageInfo2*", "pResolveImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkResolveImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginRendering(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingInfo, "const VkRenderingInfo*", "pRenderingInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRendering(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCullMode(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCullModeFlags(api_dump, cullMode, "VkCullModeFlags", "cullMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetFrontFace(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFrontFace(api_dump, frontFace, "VkFrontFace", "frontFace", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPrimitiveTopology(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrimitiveTopology(api_dump, primitiveTopology, "VkPrimitiveTopology", "primitiveTopology", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewportWithCount(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, viewportCount, "uint32_t", "viewportCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pViewports, viewportCount, "const VkViewport*", "pViewports", "const VkViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetScissorWithCount(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, scissorCount, "uint32_t", "scissorCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pScissors, scissorCount, "const VkRect2D*", "pScissors", "const VkRect2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindVertexBuffers2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstBinding, "uint32_t", "firstBinding", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindingCount, "uint32_t", "bindingCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBuffers, bindingCount, "const VkBuffer*", "pBuffers", "const VkBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pOffsets, bindingCount, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSizes, bindingCount, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pStrides, bindingCount, "const VkDeviceSize*", "pStrides", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthTestEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthTestEnable, "VkBool32", "depthTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthWriteEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthWriteEnable, "VkBool32", "depthWriteEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthCompareOp(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCompareOp(api_dump, depthCompareOp, "VkCompareOp", "depthCompareOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBoundsTestEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthBoundsTestEnable, "VkBool32", "depthBoundsTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilTestEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, stencilTestEnable, "VkBool32", "stencilTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilOp(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilFaceFlags(api_dump, faceMask, "VkStencilFaceFlags", "faceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilOp(api_dump, failOp, "VkStencilOp", "failOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilOp(api_dump, passOp, "VkStencilOp", "passOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilOp(api_dump, depthFailOp, "VkStencilOp", "depthFailOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCompareOp(api_dump, compareOp, "VkCompareOp", "compareOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRasterizerDiscardEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, rasterizerDiscardEnable, "VkBool32", "rasterizerDiscardEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBiasEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthBiasEnable, "VkBool32", "depthBiasEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPrimitiveRestartEnable(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, primitiveRestartEnable, "VkBool32", "primitiveRestartEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkMapMemory2(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryMapInfo, "const VkMemoryMapInfo*", "pMemoryMapInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMapInfo);
+        dump_separate_members(api_dump);
+        dump_type<void**>(api_dump, ppData, "void**", "ppData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUnmapMemory2(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryUnmapInfo, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryUnmapInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceImageSubresourceLayout(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceImageSubresourceInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageSubresourceInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayout, "VkSubresourceLayout2*", "pLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSubresourceLayout2(ApiDumpInstance& api_dump, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubresource, "const VkImageSubresource2*", "pSubresource", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayout, "VkSubresourceLayout2*", "pLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyMemoryToImage(ApiDumpInstance& api_dump, VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyMemoryToImageInfo, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyImageToMemory(ApiDumpInstance& api_dump, VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageToMemoryInfo, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToMemoryInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyImageToImage(ApiDumpInstance& api_dump, VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageToImageInfo, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToImageInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkTransitionImageLayout(ApiDumpInstance& api_dump, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, transitionCount, "uint32_t", "transitionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTransitions, transitionCount, "const VkHostImageLayoutTransitionInfo*", "pTransitions", "const VkHostImageLayoutTransitionInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHostImageLayoutTransitionInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSet(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, set, "uint32_t", "set", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, descriptorWriteCount, "uint32_t", "descriptorWriteCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorWrites, descriptorWriteCount, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSetWithTemplate(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorUpdateTemplate(api_dump, descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, set, "uint32_t", "set", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pData, "const void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindDescriptorSets2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindDescriptorSetsInfo, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorSetsInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushConstants2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushConstantsInfo, "const VkPushConstantsInfo*", "pPushConstantsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushConstantsInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSet2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushDescriptorSetInfo, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSetWithTemplate2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushDescriptorSetWithTemplateInfo, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetWithTemplateInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLineStipple(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, lineStippleFactor, "uint32_t", "lineStippleFactor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint16_t>(api_dump, lineStipplePattern, "uint16_t", "lineStipplePattern", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindIndexBuffer2(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, size, "VkDeviceSize", "size", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndexType(api_dump, indexType, "VkIndexType", "indexType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRenderingAreaGranularity(ApiDumpInstance& api_dump, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingAreaInfo, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAreaInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGranularity, "VkExtent2D*", "pGranularity", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRenderingAttachmentLocations(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLocationInfo, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAttachmentLocationInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRenderingInputAttachmentIndices(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInputAttachmentIndexInfo, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInputAttachmentIndexInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroySurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSupported, "VkBool32*", "pSupported", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<VkBool32>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceCapabilities, "VkSurfaceCapabilitiesKHR*", "pSurfaceCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilitiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceFormatCount, "uint32_t*", "pSurfaceFormatCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSurfaceFormats, *pSurfaceFormatCount, "VkSurfaceFormatKHR*", "pSurfaceFormats", "VkSurfaceFormatKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceFormatKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPresentModeCount, "uint32_t*", "pPresentModeCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPresentModes, *pPresentModeCount, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentModeKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateSwapchainKHR(ApiDumpInstance& api_dump, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkSwapchainCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSwapchain, "VkSwapchainKHR*", "pSwapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroySwapchainKHR(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSwapchainImagesKHR(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSwapchainImageCount, "uint32_t*", "pSwapchainImageCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSwapchainImages, *pSwapchainImageCount, "VkImage*", "pSwapchainImages", "VkImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImage);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAcquireNextImageKHR(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, timeout, "uint64_t", "timeout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSemaphore(api_dump, semaphore, "VkSemaphore", "semaphore", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageIndex, "uint32_t*", "pImageIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueuePresentKHR(ApiDumpInstance& api_dump, VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPresentInfo, "const VkPresentInfoKHR*", "pPresentInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDeviceGroupPresentCapabilities, "VkDeviceGroupPresentCapabilitiesKHR*", "pDeviceGroupPresentCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentCapabilitiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceGroupSurfacePresentModesKHR(ApiDumpInstance& api_dump, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pModes, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentModeFlagsKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDevicePresentRectanglesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRectCount, "uint32_t*", "pRectCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pRects, *pRectCount, "VkRect2D*", "pRects", "VkRect2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAcquireNextImage2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAcquireInfo, "const VkAcquireNextImageInfoKHR*", "pAcquireInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAcquireNextImageInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageIndex, "uint32_t*", "pImageIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkDisplayPropertiesKHR*", "pProperties", "VkDisplayPropertiesKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkDisplayPlanePropertiesKHR*", "pProperties", "VkDisplayPlanePropertiesKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlanePropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, planeIndex, "uint32_t", "planeIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplayCount, "uint32_t*", "pDisplayCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDisplays, *pDisplayCount, "VkDisplayKHR*", "pDisplays", "VkDisplayKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDisplayModePropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkDisplayModePropertiesKHR*", "pProperties", "VkDisplayModePropertiesKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModePropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDisplayModeKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDisplayModeCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMode, "VkDisplayModeKHR*", "pMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDisplayPlaneCapabilitiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayModeKHR(api_dump, mode, "VkDisplayModeKHR", "mode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, planeIndex, "uint32_t", "planeIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCapabilities, "VkDisplayPlaneCapabilitiesKHR*", "pCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneCapabilitiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDisplayPlaneSurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDisplaySurfaceCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplaySurfaceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateSharedSwapchainsKHR(ApiDumpInstance& api_dump, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, swapchainCount, "uint32_t", "swapchainCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, swapchainCount, "const VkSwapchainCreateInfoKHR*", "pCreateInfos", "const VkSwapchainCreateInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSwapchains, swapchainCount, "VkSwapchainKHR*", "pSwapchains", "VkSwapchainKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateXlibSurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkXlibSurfaceCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkXlibSurfaceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<Display*>(api_dump, dpy, "Display*", "dpy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VisualID>(api_dump, visualID, "VisualID", "visualID", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateXcbSurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkXcbSurfaceCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkXcbSurfaceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<xcb_connection_t*>(api_dump, connection, "xcb_connection_t*", "connection", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<xcb_visualid_t>(api_dump, visual_id, "xcb_visualid_t", "visual_id", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateWaylandSurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkWaylandSurfaceCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWaylandSurfaceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<struct wl_display*>(api_dump, display, "struct wl_display*", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateAndroidSurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkAndroidSurfaceCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAndroidSurfaceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateWin32SurfaceKHR(ApiDumpInstance& api_dump, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkWin32SurfaceCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWin32SurfaceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVideoProfile, "const VkVideoProfileInfoKHR*", "pVideoProfile", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoProfileInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCapabilities, "VkVideoCapabilitiesKHR*", "pCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoCapabilitiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVideoFormatInfo, "const VkPhysicalDeviceVideoFormatInfoKHR*", "pVideoFormatInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceVideoFormatInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVideoFormatPropertyCount, "uint32_t*", "pVideoFormatPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pVideoFormatProperties, *pVideoFormatPropertyCount, "VkVideoFormatPropertiesKHR*", "pVideoFormatProperties", "VkVideoFormatPropertiesKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoFormatPropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateVideoSessionKHR(ApiDumpInstance& api_dump, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkVideoSessionCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVideoSession, "VkVideoSessionKHR*", "pVideoSession", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyVideoSessionKHR(ApiDumpInstance& api_dump, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkVideoSessionKHR(api_dump, videoSession, "VkVideoSessionKHR", "videoSession", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetVideoSessionMemoryRequirementsKHR(ApiDumpInstance& api_dump, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkVideoSessionKHR(api_dump, videoSession, "VkVideoSessionKHR", "videoSession", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirementsCount, "uint32_t*", "pMemoryRequirementsCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMemoryRequirements, *pMemoryRequirementsCount, "VkVideoSessionMemoryRequirementsKHR*", "pMemoryRequirements", "VkVideoSessionMemoryRequirementsKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionMemoryRequirementsKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindVideoSessionMemoryKHR(ApiDumpInstance& api_dump, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkVideoSessionKHR(api_dump, videoSession, "VkVideoSessionKHR", "videoSession", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindSessionMemoryInfoCount, "uint32_t", "bindSessionMemoryInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindSessionMemoryInfos, bindSessionMemoryInfoCount, "const VkBindVideoSessionMemoryInfoKHR*", "pBindSessionMemoryInfos", "const VkBindVideoSessionMemoryInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindVideoSessionMemoryInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateVideoSessionParametersKHR(ApiDumpInstance& api_dump, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkVideoSessionParametersCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVideoSessionParameters, "VkVideoSessionParametersKHR*", "pVideoSessionParameters", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUpdateVideoSessionParametersKHR(ApiDumpInstance& api_dump, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkVideoSessionParametersKHR(api_dump, videoSessionParameters, "VkVideoSessionParametersKHR", "videoSessionParameters", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pUpdateInfo, "const VkVideoSessionParametersUpdateInfoKHR*", "pUpdateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersUpdateInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyVideoSessionParametersKHR(ApiDumpInstance& api_dump, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkVideoSessionParametersKHR(api_dump, videoSessionParameters, "VkVideoSessionParametersKHR", "videoSessionParameters", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginVideoCodingKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBeginInfo, "const VkVideoBeginCodingInfoKHR*", "pBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoBeginCodingInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndVideoCodingKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pEndCodingInfo, "const VkVideoEndCodingInfoKHR*", "pEndCodingInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEndCodingInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdControlVideoCodingKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCodingControlInfo, "const VkVideoCodingControlInfoKHR*", "pCodingControlInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoCodingControlInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDecodeVideoKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDecodeInfo, "const VkVideoDecodeInfoKHR*", "pDecodeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoDecodeInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginRenderingKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingInfo, "const VkRenderingInfo*", "pRenderingInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRenderingKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFeatures2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFeatures, "VkPhysicalDeviceFeatures2*", "pFeatures", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkPhysicalDeviceProperties2*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFormatProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFormat(api_dump, format, "VkFormat", "format", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFormatProperties, "VkFormatProperties2*", "pFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageFormatInfo, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceImageFormatInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageFormatProperties, "VkImageFormatProperties2*", "pImageFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueFamilyPropertyCount, "uint32_t*", "pQueueFamilyPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pQueueFamilyProperties, *pQueueFamilyPropertyCount, "VkQueueFamilyProperties2*", "pQueueFamilyProperties", "VkQueueFamilyProperties2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryProperties, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFormatInfo, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSparseImageFormatInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkSparseImageFormatProperties2*", "pProperties", "VkSparseImageFormatProperties2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(ApiDumpInstance& api_dump, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, heapIndex, "uint32_t", "heapIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, localDeviceIndex, "uint32_t", "localDeviceIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, remoteDeviceIndex, "uint32_t", "remoteDeviceIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPeerMemoryFeatures, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPeerMemoryFeatureFlags);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDeviceMaskKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, deviceMask, "uint32_t", "deviceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchBaseKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, baseGroupX, "uint32_t", "baseGroupX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, baseGroupY, "uint32_t", "baseGroupY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, baseGroupZ, "uint32_t", "baseGroupZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountX, "uint32_t", "groupCountX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountY, "uint32_t", "groupCountY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountZ, "uint32_t", "groupCountZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkTrimCommandPoolKHR(ApiDumpInstance& api_dump, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPool(api_dump, commandPool, "VkCommandPool", "commandPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCommandPoolTrimFlags(api_dump, flags, "VkCommandPoolTrimFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumeratePhysicalDeviceGroupsKHR(ApiDumpInstance& api_dump, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPhysicalDeviceGroupCount, "uint32_t*", "pPhysicalDeviceGroupCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, "VkPhysicalDeviceGroupProperties*", "pPhysicalDeviceGroupProperties", "VkPhysicalDeviceGroupProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceGroupProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalBufferInfo, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalBufferInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalBufferProperties, "VkExternalBufferProperties*", "pExternalBufferProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalBufferProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetMemoryWin32HandleKHR(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetWin32HandleInfo, "const VkMemoryGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetWin32HandleInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHandle, "HANDLE*", "pHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<HANDLE>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryWin32HandlePropertiesKHR(ApiDumpInstance& api_dump, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagBits(api_dump, handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<HANDLE>(api_dump, handle, "HANDLE", "handle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryWin32HandleProperties, "VkMemoryWin32HandlePropertiesKHR*", "pMemoryWin32HandleProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryWin32HandlePropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetMemoryFdKHR(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetFdInfo, "const VkMemoryGetFdInfoKHR*", "pGetFdInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetFdInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFd, "int*", "pFd", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<int>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryFdPropertiesKHR(ApiDumpInstance& api_dump, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagBits(api_dump, handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<int>(api_dump, fd, "int", "fd", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryFdProperties, "VkMemoryFdPropertiesKHR*", "pMemoryFdProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryFdPropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalSemaphoreInfo, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalSemaphoreInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalSemaphoreProperties, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalSemaphoreProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkImportSemaphoreWin32HandleKHR(ApiDumpInstance& api_dump, VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImportSemaphoreWin32HandleInfo, "const VkImportSemaphoreWin32HandleInfoKHR*", "pImportSemaphoreWin32HandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreWin32HandleInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSemaphoreWin32HandleKHR(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetWin32HandleInfo, "const VkSemaphoreGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetWin32HandleInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHandle, "HANDLE*", "pHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<HANDLE>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkImportSemaphoreFdKHR(ApiDumpInstance& api_dump, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImportSemaphoreFdInfo, "const VkImportSemaphoreFdInfoKHR*", "pImportSemaphoreFdInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreFdInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSemaphoreFdKHR(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetFdInfo, "const VkSemaphoreGetFdInfoKHR*", "pGetFdInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetFdInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFd, "int*", "pFd", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<int>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSetKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, set, "uint32_t", "set", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, descriptorWriteCount, "uint32_t", "descriptorWriteCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptorWrites, descriptorWriteCount, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSetWithTemplateKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorUpdateTemplate(api_dump, descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, set, "uint32_t", "set", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pData, "const void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDescriptorUpdateTemplateKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplateCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDescriptorUpdateTemplate, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplate);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDescriptorUpdateTemplateKHR(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorUpdateTemplate(api_dump, descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUpdateDescriptorSetWithTemplateKHR(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorSet(api_dump, descriptorSet, "VkDescriptorSet", "descriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorUpdateTemplate(api_dump, descriptorUpdateTemplate, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pData, "const void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateRenderPass2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkRenderPassCreateInfo2*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderPass, "VkRenderPass*", "pRenderPass", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginRenderPass2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderPassBegin, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassBeginInfo, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdNextSubpass2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassBeginInfo, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassEndInfo, "const VkSubpassEndInfo*", "pSubpassEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRenderPass2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubpassEndInfo, "const VkSubpassEndInfo*", "pSubpassEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSwapchainStatusKHR(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalFenceInfo, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalFenceInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalFenceProperties, "VkExternalFenceProperties*", "pExternalFenceProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalFenceProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkImportFenceWin32HandleKHR(ApiDumpInstance& api_dump, VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImportFenceWin32HandleInfo, "const VkImportFenceWin32HandleInfoKHR*", "pImportFenceWin32HandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImportFenceWin32HandleInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetFenceWin32HandleKHR(ApiDumpInstance& api_dump, VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetWin32HandleInfo, "const VkFenceGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceGetWin32HandleInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHandle, "HANDLE*", "pHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<HANDLE>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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_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_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);
+void dump_params_vkImportFenceFdKHR(ApiDumpInstance& api_dump, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImportFenceFdInfo, "const VkImportFenceFdInfoKHR*", "pImportFenceFdInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImportFenceFdInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetFenceFdKHR(ApiDumpInstance& api_dump, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetFdInfo, "const VkFenceGetFdInfoKHR*", "pGetFdInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceGetFdInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFd, "int*", "pFd", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<int>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCounterCount, "uint32_t*", "pCounterCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounters, *pCounterCount, "VkPerformanceCounterKHR*", "pCounters", "VkPerformanceCounterKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterKHR);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounterDescriptions, *pCounterCount, "VkPerformanceCounterDescriptionKHR*", "pCounterDescriptions", "VkPerformanceCounterDescriptionKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterDescriptionKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPerformanceQueryCreateInfo, "const VkQueryPoolPerformanceCreateInfoKHR*", "pPerformanceQueryCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPoolPerformanceCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pNumPasses, "uint32_t*", "pNumPasses", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAcquireProfilingLockKHR(ApiDumpInstance& api_dump, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkAcquireProfilingLockInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAcquireProfilingLockInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleaseProfilingLockKHR(ApiDumpInstance& api_dump, VkDevice device) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceInfo, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceCapabilities, "VkSurfaceCapabilities2KHR*", "pSurfaceCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilities2KHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceInfo, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceFormatCount, "uint32_t*", "pSurfaceFormatCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSurfaceFormats, *pSurfaceFormatCount, "VkSurfaceFormat2KHR*", "pSurfaceFormats", "VkSurfaceFormat2KHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceFormat2KHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkDisplayProperties2KHR*", "pProperties", "VkDisplayProperties2KHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayProperties2KHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkDisplayPlaneProperties2KHR*", "pProperties", "VkDisplayPlaneProperties2KHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneProperties2KHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDisplayModeProperties2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkDisplayModeProperties2KHR*", "pProperties", "VkDisplayModeProperties2KHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeProperties2KHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDisplayPlaneCapabilities2KHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplayPlaneInfo, "const VkDisplayPlaneInfo2KHR*", "pDisplayPlaneInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneInfo2KHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCapabilities, "VkDisplayPlaneCapabilities2KHR*", "pCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneCapabilities2KHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageMemoryRequirements2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageMemoryRequirementsInfo2*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryRequirementsInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferMemoryRequirements2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferMemoryRequirementsInfo2*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryRequirementsInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSparseMemoryRequirements2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSparseMemoryRequirementsInfo2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSparseMemoryRequirementCount, "uint32_t*", "pSparseMemoryRequirementCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSparseMemoryRequirements, *pSparseMemoryRequirementCount, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateSamplerYcbcrConversionKHR(ApiDumpInstance& api_dump, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversionCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pYcbcrConversion, "VkSamplerYcbcrConversion*", "pYcbcrConversion", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversion);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroySamplerYcbcrConversionKHR(ApiDumpInstance& api_dump, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSamplerYcbcrConversion(api_dump, ycbcrConversion, "VkSamplerYcbcrConversion", "ycbcrConversion", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindBufferMemory2KHR(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindBufferMemoryInfo*", "pBindInfos", "const VkBindBufferMemoryInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindBufferMemoryInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindImageMemory2KHR(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindImageMemoryInfo*", "pBindInfos", "const VkBindImageMemoryInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindImageMemoryInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDescriptorSetLayoutSupportKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSupport, "VkDescriptorSetLayoutSupport*", "pSupport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutSupport);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndirectCountKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndexedIndirectCountKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSemaphoreCounterValueKHR(ApiDumpInstance& api_dump, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSemaphore(api_dump, semaphore, "VkSemaphore", "semaphore", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pValue, "uint64_t*", "pValue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWaitSemaphoresKHR(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pWaitInfo, "const VkSemaphoreWaitInfo*", "pWaitInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreWaitInfo);
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, timeout, "uint64_t", "timeout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSignalSemaphoreKHR(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSignalInfo, "const VkSemaphoreSignalInfo*", "pSignalInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreSignalInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFragmentShadingRateCount, "uint32_t*", "pFragmentShadingRateCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pFragmentShadingRates, *pFragmentShadingRateCount, "VkPhysicalDeviceFragmentShadingRateKHR*", "pFragmentShadingRates", "VkPhysicalDeviceFragmentShadingRateKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFragmentShadingRateKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetFragmentShadingRateKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFragmentSize, "const VkExtent2D*", "pFragmentSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, combinerOps, 2, "const VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "const VkFragmentShadingRateCombinerOpKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFragmentShadingRateCombinerOpKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRenderingAttachmentLocationsKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLocationInfo, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAttachmentLocationInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInputAttachmentIndexInfo, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInputAttachmentIndexInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWaitForPresentKHR(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, presentId, "uint64_t", "presentId", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, timeout, "uint64_t", "timeout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferDeviceAddressKHR(ApiDumpInstance& api_dump, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferDeviceAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferOpaqueCaptureAddressKHR(ApiDumpInstance& api_dump, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferDeviceAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemoryOpaqueCaptureAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDeferredOperationKHR(ApiDumpInstance& api_dump, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDeferredOperation, "VkDeferredOperationKHR*", "pDeferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeferredOperationKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDeferredOperationKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, operation, "VkDeferredOperationKHR", "operation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeferredOperationMaxConcurrencyKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR operation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, operation, "VkDeferredOperationKHR", "operation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeferredOperationResultKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR operation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, operation, "VkDeferredOperationKHR", "operation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDeferredOperationJoinKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR operation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, operation, "VkDeferredOperationKHR", "operation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineExecutablePropertiesKHR(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineInfo, "const VkPipelineInfoKHR*", "pPipelineInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExecutableCount, "uint32_t*", "pExecutableCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pExecutableCount, "VkPipelineExecutablePropertiesKHR*", "pProperties", "VkPipelineExecutablePropertiesKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutablePropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineExecutableStatisticsKHR(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExecutableInfo, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pStatisticCount, "uint32_t*", "pStatisticCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pStatistics, *pStatisticCount, "VkPipelineExecutableStatisticKHR*", "pStatistics", "VkPipelineExecutableStatisticKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableStatisticKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExecutableInfo, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInternalRepresentationCount, "uint32_t*", "pInternalRepresentationCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInternalRepresentations, *pInternalRepresentationCount, "VkPipelineExecutableInternalRepresentationKHR*", "pInternalRepresentations", "VkPipelineExecutableInternalRepresentationKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInternalRepresentationKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkMapMemory2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryMapInfo, "const VkMemoryMapInfo*", "pMemoryMapInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMapInfo);
+        dump_separate_members(api_dump);
+        dump_type<void**>(api_dump, ppData, "void**", "ppData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUnmapMemory2KHR(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryUnmapInfo, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryUnmapInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQualityLevelInfo, "const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*", "pQualityLevelInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQualityLevelProperties, "VkVideoEncodeQualityLevelPropertiesKHR*", "pQualityLevelProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeQualityLevelPropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetEncodedVideoSessionParametersKHR(ApiDumpInstance& api_dump, VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVideoSessionParametersInfo, "const VkVideoEncodeSessionParametersGetInfoKHR*", "pVideoSessionParametersInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeSessionParametersGetInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFeedbackInfo, "VkVideoEncodeSessionParametersFeedbackInfoKHR*", "pFeedbackInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeSessionParametersFeedbackInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDataSize, "size_t*", "pDataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEncodeVideoKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pEncodeInfo, "const VkVideoEncodeInfoKHR*", "pEncodeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetEvent2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDependencyInfo, "const VkDependencyInfo*", "pDependencyInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResetEvent2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkEvent(api_dump, event, "VkEvent", "event", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags2(api_dump, stageMask, "VkPipelineStageFlags2", "stageMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWaitEvents2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, eventCount, "uint32_t", "eventCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pEvents, eventCount, "const VkEvent*", "pEvents", "const VkEvent", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDependencyInfos, eventCount, "const VkDependencyInfo*", "pDependencyInfos", "const VkDependencyInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPipelineBarrier2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDependencyInfo, "const VkDependencyInfo*", "pDependencyInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteTimestamp2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags2(api_dump, stage, "VkPipelineStageFlags2", "stage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueSubmit2KHR(ApiDumpInstance& api_dump, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, submitCount, "uint32_t", "submitCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSubmits, submitCount, "const VkSubmitInfo2*", "pSubmits", "const VkSubmitInfo2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo2);
+        dump_separate_members(api_dump);
+        dump_VkFence(api_dump, fence, "VkFence", "fence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyBuffer2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyBufferInfo, "const VkCopyBufferInfo2*", "pCopyBufferInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyImage2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageInfo, "const VkCopyImageInfo2*", "pCopyImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyBufferToImage2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyBufferToImageInfo, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferToImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyImageToBuffer2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageToBufferInfo, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToBufferInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBlitImage2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBlitImageInfo, "const VkBlitImageInfo2*", "pBlitImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBlitImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdResolveImage2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pResolveImageInfo, "const VkResolveImageInfo2*", "pResolveImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkResolveImageInfo2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdTraceRaysIndirect2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, indirectDeviceAddress, "VkDeviceAddress", "indirectDeviceAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceBufferMemoryRequirementsKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceBufferMemoryRequirements*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceBufferMemoryRequirements);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceImageMemoryRequirementsKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceImageMemoryRequirements*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceImageMemoryRequirements*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSparseMemoryRequirementCount, "uint32_t*", "pSparseMemoryRequirementCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSparseMemoryRequirements, *pSparseMemoryRequirementCount, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindIndexBuffer2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, size, "VkDeviceSize", "size", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndexType(api_dump, indexType, "VkIndexType", "indexType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRenderingAreaGranularityKHR(ApiDumpInstance& api_dump, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingAreaInfo, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAreaInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGranularity, "VkExtent2D*", "pGranularity", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceImageSubresourceLayoutKHR(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceImageSubresourceInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageSubresourceInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayout, "VkSubresourceLayout2*", "pLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSubresourceLayout2KHR(ApiDumpInstance& api_dump, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubresource, "const VkImageSubresource2*", "pSubresource", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayout, "VkSubresourceLayout2*", "pLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWaitForPresent2KHR(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPresentWait2Info, "const VkPresentWait2InfoKHR*", "pPresentWait2Info", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentWait2InfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreatePipelineBinariesKHR(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkPipelineBinaryCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBinaries, "VkPipelineBinaryHandlesInfoKHR*", "pBinaries", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryHandlesInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyPipelineBinaryKHR(ApiDumpInstance& api_dump, VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBinaryKHR(api_dump, pipelineBinary, "VkPipelineBinaryKHR", "pipelineBinary", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineKeyKHR(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineCreateInfo, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineKey, "VkPipelineBinaryKeyKHR*", "pPipelineKey", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryKeyKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineBinaryDataKHR(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkPipelineBinaryDataInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryDataInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineBinaryKey, "VkPipelineBinaryKeyKHR*", "pPipelineBinaryKey", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryKeyKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineBinaryDataSize, "size_t*", "pPipelineBinaryDataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pPipelineBinaryData, "void*", "pPipelineBinaryData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleaseCapturedPipelineDataKHR(ApiDumpInstance& api_dump, VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkReleaseCapturedPipelineDataInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseCapturedPipelineDataInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleaseSwapchainImagesKHR(ApiDumpInstance& api_dump, VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pReleaseInfo, "const VkReleaseSwapchainImagesInfoKHR*", "pReleaseInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseSwapchainImagesInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkCooperativeMatrixPropertiesKHR*", "pProperties", "VkCooperativeMatrixPropertiesKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixPropertiesKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLineStippleKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, lineStippleFactor, "uint32_t", "lineStippleFactor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint16_t>(api_dump, lineStipplePattern, "uint16_t", "lineStipplePattern", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTimeDomainCount, "uint32_t*", "pTimeDomainCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTimeDomains, *pTimeDomainCount, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTimeDomainKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetCalibratedTimestampsKHR(ApiDumpInstance& api_dump, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, timestampCount, "uint32_t", "timestampCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTimestampInfos, timestampCount, "const VkCalibratedTimestampInfoKHR*", "pTimestampInfos", "const VkCalibratedTimestampInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCalibratedTimestampInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTimestamps, timestampCount, "uint64_t*", "pTimestamps", "uint64_t", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMaxDeviation, "uint64_t*", "pMaxDeviation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindDescriptorSets2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindDescriptorSetsInfo, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorSetsInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushConstants2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushConstantsInfo, "const VkPushConstantsInfo*", "pPushConstantsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushConstantsInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSet2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushDescriptorSetInfo, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushDescriptorSetWithTemplateInfo, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetWithTemplateInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDescriptorBufferOffsets2EXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSetDescriptorBufferOffsetsInfo, "const VkSetDescriptorBufferOffsetsInfoEXT*", "pSetDescriptorBufferOffsetsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSetDescriptorBufferOffsetsInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindDescriptorBufferEmbeddedSamplersInfo, "const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*", "pBindDescriptorBufferEmbeddedSamplersInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMemoryIndirectKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyMemoryIndirectInfo, "const VkCopyMemoryIndirectInfoKHR*", "pCopyMemoryIndirectInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryIndirectInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMemoryToImageIndirectKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyMemoryToImageIndirectInfo, "const VkCopyMemoryToImageIndirectInfoKHR*", "pCopyMemoryToImageIndirectInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageIndirectInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRendering2KHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingEndInfo, "const VkRenderingEndInfoKHR*", "pRenderingEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingEndInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDebugReportCallbackEXT(ApiDumpInstance& api_dump, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDebugReportCallbackCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugReportCallbackCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCallback, "VkDebugReportCallbackEXT*", "pCallback", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugReportCallbackEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDebugReportCallbackEXT(ApiDumpInstance& api_dump, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDebugReportCallbackEXT(api_dump, callback, "VkDebugReportCallbackEXT", "callback", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDebugReportMessageEXT(ApiDumpInstance& api_dump, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDebugReportFlagsEXT(api_dump, flags, "VkDebugReportFlagsEXT", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDebugReportObjectTypeEXT(api_dump, objectType, "VkDebugReportObjectTypeEXT", "objectType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, object, "uint64_t", "object", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, location, "size_t", "location", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<int32_t>(api_dump, messageCode, "int32_t", "messageCode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_char(api_dump, pLayerPrefix, "const char*", "pLayerPrefix", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_char(api_dump, pMessage, "const char*", "pMessage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDebugMarkerSetObjectTagEXT(ApiDumpInstance& api_dump, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTagInfo, "const VkDebugMarkerObjectTagInfoEXT*", "pTagInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerObjectTagInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDebugMarkerSetObjectNameEXT(ApiDumpInstance& api_dump, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pNameInfo, "const VkDebugMarkerObjectNameInfoEXT*", "pNameInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerObjectNameInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDebugMarkerBeginEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMarkerInfo, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerMarkerInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDebugMarkerEndEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDebugMarkerInsertEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMarkerInfo, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerMarkerInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindTransformFeedbackBuffersEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstBinding, "uint32_t", "firstBinding", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindingCount, "uint32_t", "bindingCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBuffers, bindingCount, "const VkBuffer*", "pBuffers", "const VkBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pOffsets, bindingCount, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSizes, bindingCount, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginTransformFeedbackEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstCounterBuffer, "uint32_t", "firstCounterBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, counterBufferCount, "uint32_t", "counterBufferCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounterBuffers, counterBufferCount, "const VkBuffer*", "pCounterBuffers", "const VkBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounterBufferOffsets, counterBufferCount, "const VkDeviceSize*", "pCounterBufferOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndTransformFeedbackEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstCounterBuffer, "uint32_t", "firstCounterBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, counterBufferCount, "uint32_t", "counterBufferCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounterBuffers, counterBufferCount, "const VkBuffer*", "pCounterBuffers", "const VkBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounterBufferOffsets, counterBufferCount, "const VkDeviceSize*", "pCounterBufferOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginQueryIndexedEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryControlFlags(api_dump, flags, "VkQueryControlFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, index, "uint32_t", "index", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndQueryIndexedEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, query, "uint32_t", "query", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, index, "uint32_t", "index", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndirectByteCountEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, instanceCount, "uint32_t", "instanceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstInstance, "uint32_t", "firstInstance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, counterBuffer, "VkBuffer", "counterBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, counterBufferOffset, "VkDeviceSize", "counterBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, counterOffset, "uint32_t", "counterOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, vertexStride, "uint32_t", "vertexStride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateCuModuleNVX(ApiDumpInstance& api_dump, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkCuModuleCreateInfoNVX*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCuModuleCreateInfoNVX);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pModule, "VkCuModuleNVX*", "pModule", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCuModuleNVX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateCuFunctionNVX(ApiDumpInstance& api_dump, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkCuFunctionCreateInfoNVX*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCuFunctionCreateInfoNVX);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFunction, "VkCuFunctionNVX*", "pFunction", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCuFunctionNVX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyCuModuleNVX(ApiDumpInstance& api_dump, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCuModuleNVX(api_dump, module, "VkCuModuleNVX", "module", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyCuFunctionNVX(ApiDumpInstance& api_dump, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCuFunctionNVX(api_dump, function, "VkCuFunctionNVX", "function", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCuLaunchKernelNVX(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLaunchInfo, "const VkCuLaunchInfoNVX*", "pLaunchInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCuLaunchInfoNVX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageViewHandleNVX(ApiDumpInstance& api_dump, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageViewHandleInfoNVX*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewHandleInfoNVX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageViewHandle64NVX(ApiDumpInstance& api_dump, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageViewHandleInfoNVX*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewHandleInfoNVX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageViewAddressNVX(ApiDumpInstance& api_dump, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageView(api_dump, imageView, "VkImageView", "imageView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkImageViewAddressPropertiesNVX*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewAddressPropertiesNVX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(ApiDumpInstance& api_dump, VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, imageViewIndex, "uint64_t", "imageViewIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, samplerIndex, "uint64_t", "samplerIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndirectCountAMD(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawIndexedIndirectCountAMD(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetShaderInfoAMD(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderStageFlagBits(api_dump, shaderStage, "VkShaderStageFlagBits", "shaderStage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderInfoTypeAMD(api_dump, infoType, "VkShaderInfoTypeAMD", "infoType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfoSize, "size_t*", "pInfoSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pInfo, "void*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateStreamDescriptorSurfaceGGP(ApiDumpInstance& api_dump, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkStreamDescriptorSurfaceCreateInfoGGP*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStreamDescriptorSurfaceCreateInfoGGP);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFormat(api_dump, format, "VkFormat", "format", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageType(api_dump, type, "VkImageType", "type", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageTiling(api_dump, tiling, "VkImageTiling", "tiling", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageUsageFlags(api_dump, usage, "VkImageUsageFlags", "usage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageCreateFlags(api_dump, flags, "VkImageCreateFlags", "flags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, externalHandleType, "VkExternalMemoryHandleTypeFlagsNV", "externalHandleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalImageFormatProperties, "VkExternalImageFormatPropertiesNV*", "pExternalImageFormatProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalImageFormatPropertiesNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetMemoryWin32HandleNV(ApiDumpInstance& api_dump, VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagsNV(api_dump, handleType, "VkExternalMemoryHandleTypeFlagsNV", "handleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHandle, "HANDLE*", "pHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<HANDLE>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateViSurfaceNN(ApiDumpInstance& api_dump, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkViSurfaceCreateInfoNN*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkViSurfaceCreateInfoNN);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCmdBeginConditionalRenderingEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pConditionalRenderingBegin, "const VkConditionalRenderingBeginInfoEXT*", "pConditionalRenderingBegin", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkConditionalRenderingBeginInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndConditionalRenderingEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewportWScalingNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstViewport, "uint32_t", "firstViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, viewportCount, "uint32_t", "viewportCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pViewportWScalings, viewportCount, "const VkViewportWScalingNV*", "pViewportWScalings", "const VkViewportWScalingNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkViewportWScalingNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleaseDisplayEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkAcquireXlibDisplayEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<Display*>(api_dump, dpy, "Display*", "dpy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRandROutputDisplayEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<Display*>(api_dump, dpy, "Display*", "dpy", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<RROutput>(api_dump, rrOutput, "RROutput", "rrOutput", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplay, "VkDisplayKHR*", "pDisplay", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceKHR(api_dump, surface, "VkSurfaceKHR", "surface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceCapabilities, "VkSurfaceCapabilities2EXT*", "pSurfaceCapabilities", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilities2EXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDisplayPowerControlEXT(ApiDumpInstance& api_dump, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplayPowerInfo, "const VkDisplayPowerInfoEXT*", "pDisplayPowerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPowerInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkRegisterDeviceEventEXT(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDeviceEventInfo, "const VkDeviceEventInfoEXT*", "pDeviceEventInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceEventInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFence, "VkFence*", "pFence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFence);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkRegisterDisplayEventEXT(ApiDumpInstance& api_dump, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplayEventInfo, "const VkDisplayEventInfoEXT*", "pDisplayEventInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayEventInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFence, "VkFence*", "pFence", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFence);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSwapchainCounterEXT(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSurfaceCounterFlagBitsEXT(api_dump, counter, "VkSurfaceCounterFlagBitsEXT", "counter", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCounterValue, "uint64_t*", "pCounterValue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRefreshCycleDurationGOOGLE(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplayTimingProperties, "VkRefreshCycleDurationGOOGLE*", "pDisplayTimingProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRefreshCycleDurationGOOGLE);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPastPresentationTimingGOOGLE(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPresentationTimingCount, "uint32_t*", "pPresentationTimingCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPresentationTimings, *pPresentationTimingCount, "VkPastPresentationTimingGOOGLE*", "pPresentationTimings", "VkPastPresentationTimingGOOGLE", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingGOOGLE);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDiscardRectangleEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstDiscardRectangle, "uint32_t", "firstDiscardRectangle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, discardRectangleCount, "uint32_t", "discardRectangleCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDiscardRectangles, discardRectangleCount, "const VkRect2D*", "pDiscardRectangles", "const VkRect2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDiscardRectangleEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, discardRectangleEnable, "VkBool32", "discardRectangleEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDiscardRectangleModeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDiscardRectangleModeEXT(api_dump, discardRectangleMode, "VkDiscardRectangleModeEXT", "discardRectangleMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetHdrMetadataEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, swapchainCount, "uint32_t", "swapchainCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSwapchains, swapchainCount, "const VkSwapchainKHR*", "pSwapchains", "const VkSwapchainKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMetadata, swapchainCount, "const VkHdrMetadataEXT*", "pMetadata", "const VkHdrMetadataEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHdrMetadataEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateIOSSurfaceMVK(ApiDumpInstance& api_dump, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkIOSSurfaceCreateInfoMVK*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIOSSurfaceCreateInfoMVK);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateMacOSSurfaceMVK(ApiDumpInstance& api_dump, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkMacOSSurfaceCreateInfoMVK*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMacOSSurfaceCreateInfoMVK);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkSetDebugUtilsObjectNameEXT(ApiDumpInstance& api_dump, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pNameInfo, "const VkDebugUtilsObjectNameInfoEXT*", "pNameInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsObjectNameInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetDebugUtilsObjectTagEXT(ApiDumpInstance& api_dump, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTagInfo, "const VkDebugUtilsObjectTagInfoEXT*", "pTagInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsObjectTagInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueBeginDebugUtilsLabelEXT(ApiDumpInstance& api_dump, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLabelInfo, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueEndDebugUtilsLabelEXT(ApiDumpInstance& api_dump, VkQueue queue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueInsertDebugUtilsLabelEXT(ApiDumpInstance& api_dump, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLabelInfo, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginDebugUtilsLabelEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLabelInfo, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndDebugUtilsLabelEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdInsertDebugUtilsLabelEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLabelInfo, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDebugUtilsMessengerEXT(ApiDumpInstance& api_dump, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDebugUtilsMessengerCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMessenger, "VkDebugUtilsMessengerEXT*", "pMessenger", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDebugUtilsMessengerEXT(ApiDumpInstance& api_dump, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDebugUtilsMessengerEXT(api_dump, messenger, "VkDebugUtilsMessengerEXT", "messenger", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSubmitDebugUtilsMessageEXT(ApiDumpInstance& api_dump, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDebugUtilsMessageSeverityFlagBitsEXT(api_dump, messageSeverity, "VkDebugUtilsMessageSeverityFlagBitsEXT", "messageSeverity", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDebugUtilsMessageTypeFlagsEXT(api_dump, messageTypes, "VkDebugUtilsMessageTypeFlagsEXT", "messageTypes", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCallbackData, "const VkDebugUtilsMessengerCallbackDataEXT*", "pCallbackData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerCallbackDataEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance& api_dump, VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const struct AHardwareBuffer*>(api_dump, buffer, "const struct AHardwareBuffer*", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkAndroidHardwareBufferPropertiesANDROID*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAndroidHardwareBufferPropertiesANDROID);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryAndroidHardwareBufferANDROID(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkMemoryGetAndroidHardwareBufferInfoANDROID*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetAndroidHardwareBufferInfoANDROID);
+        dump_separate_members(api_dump);
+        dump_type<struct AHardwareBuffer**>(api_dump, pBuffer, "struct AHardwareBuffer**", "pBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #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);
+void dump_params_vkCreateExecutionGraphPipelinesAMDX(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkExecutionGraphPipelineCreateInfoAMDX*", "pCreateInfos", "const VkExecutionGraphPipelineCreateInfoAMDX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExecutionGraphPipelineCreateInfoAMDX);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPipelines, createInfoCount, "VkPipeline*", "pPipelines", "VkPipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance& api_dump, VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, executionGraph, "VkPipeline", "executionGraph", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSizeInfo, "VkExecutionGraphPipelineScratchSizeAMDX*", "pSizeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExecutionGraphPipelineScratchSizeAMDX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(ApiDumpInstance& api_dump, VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, executionGraph, "VkPipeline", "executionGraph", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pNodeInfo, "const VkPipelineShaderStageNodeCreateInfoAMDX*", "pNodeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineShaderStageNodeCreateInfoAMDX);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pNodeIndex, "uint32_t*", "pNodeIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdInitializeGraphScratchMemoryAMDX(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, executionGraph, "VkPipeline", "executionGraph", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, scratch, "VkDeviceAddress", "scratch", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, scratchSize, "VkDeviceSize", "scratchSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchGraphAMDX(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, scratch, "VkDeviceAddress", "scratch", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, scratchSize, "VkDeviceSize", "scratchSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCountInfo, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchGraphCountInfoAMDX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchGraphIndirectAMDX(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, scratch, "VkDeviceAddress", "scratch", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, scratchSize, "VkDeviceSize", "scratchSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCountInfo, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchGraphCountInfoAMDX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchGraphIndirectCountAMDX(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, scratch, "VkDeviceAddress", "scratch", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, scratchSize, "VkDeviceSize", "scratchSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, countInfo, "VkDeviceAddress", "countInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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, VkMemoryRequirements2KHR* 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, "VkMemoryRequirements2KHR*", "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);
+void dump_params_vkWriteSamplerDescriptorsEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, samplerCount, "uint32_t", "samplerCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSamplers, samplerCount, "const VkSamplerCreateInfo*", "pSamplers", "const VkSamplerCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptors, samplerCount, "const VkHostAddressRangeEXT*", "pDescriptors", "const VkHostAddressRangeEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWriteResourceDescriptorsEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, resourceCount, "uint32_t", "resourceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pResources, resourceCount, "const VkResourceDescriptorInfoEXT*", "pResources", "const VkResourceDescriptorInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkResourceDescriptorInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDescriptors, resourceCount, "const VkHostAddressRangeEXT*", "pDescriptors", "const VkHostAddressRangeEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindSamplerHeapEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindInfo, "const VkBindHeapInfoEXT*", "pBindInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindHeapInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindResourceHeapEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindInfo, "const VkBindHeapInfoEXT*", "pBindInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindHeapInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPushDataEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPushDataInfo, "const VkPushDataInfoEXT*", "pPushDataInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDataInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageOpaqueCaptureDataEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, imageCount, "uint32_t", "imageCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pImages, imageCount, "const VkImage*", "pImages", "const VkImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImage);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDatas, imageCount, "VkHostAddressRangeEXT*", "pDatas", "VkHostAddressRangeEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorType(api_dump, descriptorType, "VkDescriptorType", "descriptorType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkRegisterCustomBorderColorEXT(ApiDumpInstance& api_dump, VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBorderColor, "const VkSamplerCustomBorderColorCreateInfoEXT*", "pBorderColor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCustomBorderColorCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, requestIndex, "VkBool32", "requestIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pIndex, "uint32_t*", "pIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUnregisterCustomBorderColorEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t index) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, index, "uint32_t", "index", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetTensorOpaqueCaptureDataARM(ApiDumpInstance& api_dump, VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, tensorCount, "uint32_t", "tensorCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTensors, tensorCount, "const VkTensorARM*", "pTensors", "const VkTensorARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorARM);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDatas, tensorCount, "VkHostAddressRangeEXT*", "pDatas", "VkHostAddressRangeEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetSampleLocationsEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSampleLocationsInfo, "const VkSampleLocationsInfoEXT*", "pSampleLocationsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSampleLocationsInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSampleCountFlagBits(api_dump, samples, "VkSampleCountFlagBits", "samples", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMultisampleProperties, "VkMultisamplePropertiesEXT*", "pMultisampleProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMultisamplePropertiesEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageDrmFormatModifierPropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkImageDrmFormatModifierPropertiesEXT*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageDrmFormatModifierPropertiesEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateValidationCacheEXT(ApiDumpInstance& api_dump, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkValidationCacheCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pValidationCache, "VkValidationCacheEXT*", "pValidationCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyValidationCacheEXT(ApiDumpInstance& api_dump, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkValidationCacheEXT(api_dump, validationCache, "VkValidationCacheEXT", "validationCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkMergeValidationCachesEXT(ApiDumpInstance& api_dump, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkValidationCacheEXT(api_dump, dstCache, "VkValidationCacheEXT", "dstCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, srcCacheCount, "uint32_t", "srcCacheCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSrcCaches, srcCacheCount, "const VkValidationCacheEXT*", "pSrcCaches", "const VkValidationCacheEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetValidationCacheDataEXT(ApiDumpInstance& api_dump, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkValidationCacheEXT(api_dump, validationCache, "VkValidationCacheEXT", "validationCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDataSize, "size_t*", "pDataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindShadingRateImageNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageView(api_dump, imageView, "VkImageView", "imageView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, imageLayout, "VkImageLayout", "imageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewportShadingRatePaletteNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstViewport, "uint32_t", "firstViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, viewportCount, "uint32_t", "viewportCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pShadingRatePalettes, viewportCount, "const VkShadingRatePaletteNV*", "pShadingRatePalettes", "const VkShadingRatePaletteNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShadingRatePaletteNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoarseSampleOrderNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCoarseSampleOrderTypeNV(api_dump, sampleOrderType, "VkCoarseSampleOrderTypeNV", "sampleOrderType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, customSampleOrderCount, "uint32_t", "customSampleOrderCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCustomSampleOrders, customSampleOrderCount, "const VkCoarseSampleOrderCustomNV*", "pCustomSampleOrders", "const VkCoarseSampleOrderCustomNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCoarseSampleOrderCustomNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateAccelerationStructureNV(ApiDumpInstance& api_dump, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkAccelerationStructureCreateInfoNV*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAccelerationStructure, "VkAccelerationStructureNV*", "pAccelerationStructure", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyAccelerationStructureNV(ApiDumpInstance& api_dump, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureNV(api_dump, accelerationStructure, "VkAccelerationStructureNV", "accelerationStructure", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetAccelerationStructureMemoryRequirementsNV(ApiDumpInstance& api_dump, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkAccelerationStructureMemoryRequirementsInfoNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureMemoryRequirementsInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2KHR*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindAccelerationStructureMemoryNV(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindAccelerationStructureMemoryInfoNV*", "pBindInfos", "const VkBindAccelerationStructureMemoryInfoNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindAccelerationStructureMemoryInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBuildAccelerationStructureNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkAccelerationStructureInfoNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureInfoNV);
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, instanceData, "VkBuffer", "instanceData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, instanceOffset, "VkDeviceSize", "instanceOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, update, "VkBool32", "update", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureNV(api_dump, dst, "VkAccelerationStructureNV", "dst", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureNV(api_dump, src, "VkAccelerationStructureNV", "src", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, scratch, "VkBuffer", "scratch", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, scratchOffset, "VkDeviceSize", "scratchOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyAccelerationStructureNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureNV(api_dump, dst, "VkAccelerationStructureNV", "dst", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureNV(api_dump, src, "VkAccelerationStructureNV", "src", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCopyAccelerationStructureModeKHR(api_dump, mode, "VkCopyAccelerationStructureModeKHR", "mode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdTraceRaysNV(ApiDumpInstance& api_dump, 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) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, raygenShaderBindingTableBuffer, "VkBuffer", "raygenShaderBindingTableBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, raygenShaderBindingOffset, "VkDeviceSize", "raygenShaderBindingOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, missShaderBindingTableBuffer, "VkBuffer", "missShaderBindingTableBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, missShaderBindingOffset, "VkDeviceSize", "missShaderBindingOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, missShaderBindingStride, "VkDeviceSize", "missShaderBindingStride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, hitShaderBindingTableBuffer, "VkBuffer", "hitShaderBindingTableBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, hitShaderBindingOffset, "VkDeviceSize", "hitShaderBindingOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, hitShaderBindingStride, "VkDeviceSize", "hitShaderBindingStride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, callableShaderBindingTableBuffer, "VkBuffer", "callableShaderBindingTableBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, callableShaderBindingOffset, "VkDeviceSize", "callableShaderBindingOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, callableShaderBindingStride, "VkDeviceSize", "callableShaderBindingStride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, width, "uint32_t", "width", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, height, "uint32_t", "height", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, depth, "uint32_t", "depth", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateRayTracingPipelinesNV(ApiDumpInstance& api_dump, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkRayTracingPipelineCreateInfoNV*", "pCreateInfos", "const VkRayTracingPipelineCreateInfoNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRayTracingPipelineCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPipelines, createInfoCount, "VkPipeline*", "pPipelines", "VkPipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRayTracingShaderGroupHandlesKHR(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstGroup, "uint32_t", "firstGroup", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCount, "uint32_t", "groupCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRayTracingShaderGroupHandlesNV(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstGroup, "uint32_t", "firstGroup", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCount, "uint32_t", "groupCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetAccelerationStructureHandleNV(ApiDumpInstance& api_dump, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureNV(api_dump, accelerationStructure, "VkAccelerationStructureNV", "accelerationStructure", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, accelerationStructureCount, "uint32_t", "accelerationStructureCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pAccelerationStructures, accelerationStructureCount, "const VkAccelerationStructureNV*", "pAccelerationStructures", "const VkAccelerationStructureNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureNV);
+        dump_separate_members(api_dump);
+        dump_VkQueryType(api_dump, queryType, "VkQueryType", "queryType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCompileDeferredNV(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, uint32_t shader) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, shader, "uint32_t", "shader", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryHostPointerPropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagBits(api_dump, handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pHostPointer, "const void*", "pHostPointer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryHostPointerProperties, "VkMemoryHostPointerPropertiesEXT*", "pMemoryHostPointerProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryHostPointerPropertiesEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteBufferMarkerAMD(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlagBits(api_dump, pipelineStage, "VkPipelineStageFlagBits", "pipelineStage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, dstOffset, "VkDeviceSize", "dstOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, marker, "uint32_t", "marker", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteBufferMarker2AMD(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineStageFlags2(api_dump, stage, "VkPipelineStageFlags2", "stage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, dstBuffer, "VkBuffer", "dstBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, dstOffset, "VkDeviceSize", "dstOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, marker, "uint32_t", "marker", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTimeDomainCount, "uint32_t*", "pTimeDomainCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTimeDomains, *pTimeDomainCount, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTimeDomainKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetCalibratedTimestampsEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, timestampCount, "uint32_t", "timestampCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTimestampInfos, timestampCount, "const VkCalibratedTimestampInfoKHR*", "pTimestampInfos", "const VkCalibratedTimestampInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCalibratedTimestampInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTimestamps, timestampCount, "uint64_t*", "pTimestamps", "uint64_t", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMaxDeviation, "uint64_t*", "pMaxDeviation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMeshTasksNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, taskCount, "uint32_t", "taskCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstTask, "uint32_t", "firstTask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMeshTasksIndirectNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, drawCount, "uint32_t", "drawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMeshTasksIndirectCountNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetExclusiveScissorEnableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstExclusiveScissor, "uint32_t", "firstExclusiveScissor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, exclusiveScissorCount, "uint32_t", "exclusiveScissorCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pExclusiveScissorEnables, exclusiveScissorCount, "const VkBool32*", "pExclusiveScissorEnables", "const VkBool32", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkBool32>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetExclusiveScissorNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstExclusiveScissor, "uint32_t", "firstExclusiveScissor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, exclusiveScissorCount, "uint32_t", "exclusiveScissorCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pExclusiveScissors, exclusiveScissorCount, "const VkRect2D*", "pExclusiveScissors", "const VkRect2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCheckpointNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pCheckpointMarker, "const void*", "pCheckpointMarker", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetQueueCheckpointDataNV(ApiDumpInstance& api_dump, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCheckpointDataCount, "uint32_t*", "pCheckpointDataCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCheckpointData, *pCheckpointDataCount, "VkCheckpointDataNV*", "pCheckpointData", "VkCheckpointDataNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCheckpointDataNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetQueueCheckpointData2NV(ApiDumpInstance& api_dump, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCheckpointDataCount, "uint32_t*", "pCheckpointDataCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCheckpointData, *pCheckpointDataCount, "VkCheckpointData2NV*", "pCheckpointData", "VkCheckpointData2NV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCheckpointData2NV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, uint32_t size) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, size, "uint32_t", "size", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSwapchainTimingPropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSwapchainTimingProperties, "VkSwapchainTimingPropertiesEXT*", "pSwapchainTimingProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainTimingPropertiesEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSwapchainTimingPropertiesCounter, "uint64_t*", "pSwapchainTimingPropertiesCounter", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSwapchainTimeDomainPropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSwapchainTimeDomainProperties, "VkSwapchainTimeDomainPropertiesEXT*", "pSwapchainTimeDomainProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainTimeDomainPropertiesEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTimeDomainsCounter, "uint64_t*", "pTimeDomainsCounter", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPastPresentationTimingEXT(ApiDumpInstance& api_dump, VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPastPresentationTimingInfo, "const VkPastPresentationTimingInfoEXT*", "pPastPresentationTimingInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPastPresentationTimingProperties, "VkPastPresentationTimingPropertiesEXT*", "pPastPresentationTimingProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingPropertiesEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkInitializePerformanceApiINTEL(ApiDumpInstance& api_dump, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInitializeInfo, "const VkInitializePerformanceApiInfoINTEL*", "pInitializeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkInitializePerformanceApiInfoINTEL);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUninitializePerformanceApiINTEL(ApiDumpInstance& api_dump, VkDevice device) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPerformanceMarkerINTEL(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMarkerInfo, "const VkPerformanceMarkerInfoINTEL*", "pMarkerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceMarkerInfoINTEL);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPerformanceStreamMarkerINTEL(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMarkerInfo, "const VkPerformanceStreamMarkerInfoINTEL*", "pMarkerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceStreamMarkerInfoINTEL);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPerformanceOverrideINTEL(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pOverrideInfo, "const VkPerformanceOverrideInfoINTEL*", "pOverrideInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceOverrideInfoINTEL);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAcquirePerformanceConfigurationINTEL(ApiDumpInstance& api_dump, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAcquireInfo, "const VkPerformanceConfigurationAcquireInfoINTEL*", "pAcquireInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceConfigurationAcquireInfoINTEL);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pConfiguration, "VkPerformanceConfigurationINTEL*", "pConfiguration", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceConfigurationINTEL);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleasePerformanceConfigurationINTEL(ApiDumpInstance& api_dump, VkDevice device, VkPerformanceConfigurationINTEL configuration) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPerformanceConfigurationINTEL(api_dump, configuration, "VkPerformanceConfigurationINTEL", "configuration", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueSetPerformanceConfigurationINTEL(ApiDumpInstance& api_dump, VkQueue queue, VkPerformanceConfigurationINTEL configuration) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPerformanceConfigurationINTEL(api_dump, configuration, "VkPerformanceConfigurationINTEL", "configuration", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPerformanceParameterINTEL(ApiDumpInstance& api_dump, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPerformanceParameterTypeINTEL(api_dump, parameter, "VkPerformanceParameterTypeINTEL", "parameter", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pValue, "VkPerformanceValueINTEL*", "pValue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceValueINTEL);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetLocalDimmingAMD(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapChain, "VkSwapchainKHR", "swapChain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, localDimmingEnable, "VkBool32", "localDimmingEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateImagePipeSurfaceFUCHSIA(ApiDumpInstance& api_dump, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkImagePipeSurfaceCreateInfoFUCHSIA*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImagePipeSurfaceCreateInfoFUCHSIA);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateMetalSurfaceEXT(ApiDumpInstance& api_dump, VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkMetalSurfaceCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMetalSurfaceCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetBufferDeviceAddressEXT(ApiDumpInstance& api_dump, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferDeviceAddressInfo*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceToolPropertiesEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pToolCount, "uint32_t*", "pToolCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pToolProperties, *pToolCount, "VkPhysicalDeviceToolProperties*", "pToolProperties", "VkPhysicalDeviceToolProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceToolProperties);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkCooperativeMatrixPropertiesNV*", "pProperties", "VkCooperativeMatrixPropertiesNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixPropertiesNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCombinationCount, "uint32_t*", "pCombinationCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCombinations, *pCombinationCount, "VkFramebufferMixedSamplesCombinationNV*", "pCombinations", "VkFramebufferMixedSamplesCombinationNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebufferMixedSamplesCombinationNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceInfo, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPresentModeCount, "uint32_t*", "pPresentModeCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPresentModes, *pPresentModeCount, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentModeKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAcquireFullScreenExclusiveModeEXT(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleaseFullScreenExclusiveModeEXT(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(ApiDumpInstance& api_dump, VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurfaceInfo, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pModes, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentModeFlagsKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateHeadlessSurfaceEXT(ApiDumpInstance& api_dump, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkHeadlessSurfaceCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHeadlessSurfaceCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLineStippleEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, lineStippleFactor, "uint32_t", "lineStippleFactor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint16_t>(api_dump, lineStipplePattern, "uint16_t", "lineStipplePattern", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkResetQueryPoolEXT(ApiDumpInstance& api_dump, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queryCount, "uint32_t", "queryCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCullModeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCullModeFlags(api_dump, cullMode, "VkCullModeFlags", "cullMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetFrontFaceEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFrontFace(api_dump, frontFace, "VkFrontFace", "frontFace", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPrimitiveTopologyEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrimitiveTopology(api_dump, primitiveTopology, "VkPrimitiveTopology", "primitiveTopology", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewportWithCountEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, viewportCount, "uint32_t", "viewportCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pViewports, viewportCount, "const VkViewport*", "pViewports", "const VkViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetScissorWithCountEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, scissorCount, "uint32_t", "scissorCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pScissors, scissorCount, "const VkRect2D*", "pScissors", "const VkRect2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindVertexBuffers2EXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstBinding, "uint32_t", "firstBinding", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindingCount, "uint32_t", "bindingCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBuffers, bindingCount, "const VkBuffer*", "pBuffers", "const VkBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pOffsets, bindingCount, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSizes, bindingCount, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pStrides, bindingCount, "const VkDeviceSize*", "pStrides", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthTestEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthTestEnable, "VkBool32", "depthTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthWriteEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthWriteEnable, "VkBool32", "depthWriteEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthCompareOpEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCompareOp(api_dump, depthCompareOp, "VkCompareOp", "depthCompareOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBoundsTestEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthBoundsTestEnable, "VkBool32", "depthBoundsTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilTestEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, stencilTestEnable, "VkBool32", "stencilTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetStencilOpEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilFaceFlags(api_dump, faceMask, "VkStencilFaceFlags", "faceMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilOp(api_dump, failOp, "VkStencilOp", "failOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilOp(api_dump, passOp, "VkStencilOp", "passOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkStencilOp(api_dump, depthFailOp, "VkStencilOp", "depthFailOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCompareOp(api_dump, compareOp, "VkCompareOp", "compareOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyMemoryToImageEXT(ApiDumpInstance& api_dump, VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyMemoryToImageInfo, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyImageToMemoryEXT(ApiDumpInstance& api_dump, VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageToMemoryInfo, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToMemoryInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyImageToImageEXT(ApiDumpInstance& api_dump, VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyImageToImageInfo, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToImageInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkTransitionImageLayoutEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, transitionCount, "uint32_t", "transitionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pTransitions, transitionCount, "const VkHostImageLayoutTransitionInfo*", "pTransitions", "const VkHostImageLayoutTransitionInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkHostImageLayoutTransitionInfo);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageSubresourceLayout2EXT(ApiDumpInstance& api_dump, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, image, "VkImage", "image", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSubresource, "const VkImageSubresource2*", "pSubresource", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayout, "VkSubresourceLayout2*", "pLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkReleaseSwapchainImagesEXT(ApiDumpInstance& api_dump, VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pReleaseInfo, "const VkReleaseSwapchainImagesInfoKHR*", "pReleaseInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseSwapchainImagesInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(ApiDumpInstance& api_dump, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkGeneratedCommandsMemoryRequirementsInfoNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsMemoryRequirementsInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPreprocessGeneratedCommandsNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGeneratedCommandsInfo, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdExecuteGeneratedCommandsNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, isPreprocessed, "VkBool32", "isPreprocessed", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGeneratedCommandsInfo, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindPipelineShaderGroupNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupIndex, "uint32_t", "groupIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateIndirectCommandsLayoutNV(ApiDumpInstance& api_dump, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkIndirectCommandsLayoutCreateInfoNV*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pIndirectCommandsLayout, "VkIndirectCommandsLayoutNV*", "pIndirectCommandsLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyIndirectCommandsLayoutNV(ApiDumpInstance& api_dump, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndirectCommandsLayoutNV(api_dump, indirectCommandsLayout, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBias2EXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDepthBiasInfo, "const VkDepthBiasInfoEXT*", "pDepthBiasInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDepthBiasInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAcquireDrmDisplayEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<int32_t>(api_dump, drmFd, "int32_t", "drmFd", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDrmDisplayEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<int32_t>(api_dump, drmFd, "int32_t", "drmFd", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, connectorId, "uint32_t", "connectorId", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, display, "VkDisplayKHR*", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreatePrivateDataSlotEXT(ApiDumpInstance& api_dump, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlotCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPrivateDataSlot, "VkPrivateDataSlot*", "pPrivateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlot);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyPrivateDataSlotEXT(ApiDumpInstance& api_dump, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrivateDataSlot(api_dump, privateDataSlot, "VkPrivateDataSlot", "privateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetPrivateDataEXT(ApiDumpInstance& api_dump, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkObjectType(api_dump, objectType, "VkObjectType", "objectType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_uint64_t_as_pointer(api_dump, objectHandle, "uint64_t", "objectHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrivateDataSlot(api_dump, privateDataSlot, "VkPrivateDataSlot", "privateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint64_t>(api_dump, data, "uint64_t", "data", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPrivateDataEXT(ApiDumpInstance& api_dump, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkObjectType(api_dump, objectType, "VkObjectType", "objectType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_uint64_t_as_pointer(api_dump, objectHandle, "uint64_t", "objectHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPrivateDataSlot(api_dump, privateDataSlot, "VkPrivateDataSlot", "privateDataSlot", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pData, "uint64_t*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint64_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateCudaModuleNV(ApiDumpInstance& api_dump, VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkCudaModuleCreateInfoNV*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaModuleCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pModule, "VkCudaModuleNV*", "pModule", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaModuleNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetCudaModuleCacheNV(ApiDumpInstance& api_dump, VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCudaModuleNV(api_dump, module, "VkCudaModuleNV", "module", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCacheSize, "size_t*", "pCacheSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pCacheData, "void*", "pCacheData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateCudaFunctionNV(ApiDumpInstance& api_dump, VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkCudaFunctionCreateInfoNV*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaFunctionCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFunction, "VkCudaFunctionNV*", "pFunction", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaFunctionNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyCudaModuleNV(ApiDumpInstance& api_dump, VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCudaModuleNV(api_dump, module, "VkCudaModuleNV", "module", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyCudaFunctionNV(ApiDumpInstance& api_dump, VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCudaFunctionNV(api_dump, function, "VkCudaFunctionNV", "function", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCudaLaunchKernelNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLaunchInfo, "const VkCudaLaunchInfoNV*", "pLaunchInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaLaunchInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCmdDispatchTileQCOM(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDispatchTileInfo, "const VkDispatchTileInfoQCOM*", "pDispatchTileInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchTileInfoQCOM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 
-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);
+void dump_params_vkCmdBeginPerTileExecutionQCOM(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPerTileBeginInfo, "const VkPerTileBeginInfoQCOM*", "pPerTileBeginInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerTileBeginInfoQCOM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 
-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);
+void dump_params_vkCmdEndPerTileExecutionQCOM(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPerTileEndInfo, "const VkPerTileEndInfoQCOM*", "pPerTileEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerTileEndInfoQCOM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkExportMetalObjectsEXT(ApiDumpInstance& api_dump, VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMetalObjectsInfo, "VkExportMetalObjectsInfoEXT*", "pMetalObjectsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExportMetalObjectsInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetDescriptorSetLayoutSizeEXT(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorSetLayout(api_dump, layout, "VkDescriptorSetLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLayoutSizeInBytes, "VkDeviceSize*", "pLayoutSizeInBytes", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorSetLayout(api_dump, layout, "VkDescriptorSetLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, binding, "uint32_t", "binding", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pOffset, "VkDeviceSize*", "pOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDescriptorEXT(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDescriptorInfo, "const VkDescriptorGetInfoEXT*", "pDescriptorInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorGetInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pDescriptor, "void*", "pDescriptor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindDescriptorBuffersEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bufferCount, "uint32_t", "bufferCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindingInfos, bufferCount, "const VkDescriptorBufferBindingInfoEXT*", "pBindingInfos", "const VkDescriptorBufferBindingInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorBufferBindingInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDescriptorBufferOffsetsEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstSet, "uint32_t", "firstSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, setCount, "uint32_t", "setCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBufferIndices, setCount, "const uint32_t*", "pBufferIndices", "const uint32_t", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pOffsets, setCount, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceSize>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineLayout(api_dump, layout, "VkPipelineLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, set, "uint32_t", "set", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& api_dump, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkBufferCaptureDescriptorDataInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCaptureDescriptorDataInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& api_dump, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageCaptureDescriptorDataInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCaptureDescriptorDataInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& api_dump, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkImageViewCaptureDescriptorDataInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewCaptureDescriptorDataInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& api_dump, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkSamplerCaptureDescriptorDataInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCaptureDescriptorDataInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& api_dump, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkAccelerationStructureCaptureDescriptorDataInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetFragmentShadingRateEnumNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFragmentShadingRateNV(api_dump, shadingRate, "VkFragmentShadingRateNV", "shadingRate", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, combinerOps, 2, "const VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "const VkFragmentShadingRateCombinerOpKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkFragmentShadingRateCombinerOpKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceFaultInfoEXT(ApiDumpInstance& api_dump, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFaultCounts, "VkDeviceFaultCountsEXT*", "pFaultCounts", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultCountsEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFaultInfo, "VkDeviceFaultInfoEXT*", "pFaultInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkAcquireWinrtDisplayNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDisplayKHR(api_dump, display, "VkDisplayKHR", "display", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetWinrtDisplayNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, deviceRelativeId, "uint32_t", "deviceRelativeId", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDisplay, "VkDisplayKHR*", "pDisplay", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateDirectFBSurfaceEXT(ApiDumpInstance& api_dump, VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDirectFBSurfaceCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDirectFBSurfaceCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<IDirectFB*>(api_dump, dfb, "IDirectFB*", "dfb", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCmdSetVertexInputEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, vertexBindingDescriptionCount, "uint32_t", "vertexBindingDescriptionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pVertexBindingDescriptions, vertexBindingDescriptionCount, "const VkVertexInputBindingDescription2EXT*", "pVertexBindingDescriptions", "const VkVertexInputBindingDescription2EXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVertexInputBindingDescription2EXT);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, vertexAttributeDescriptionCount, "uint32_t", "vertexAttributeDescriptionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pVertexAttributeDescriptions, vertexAttributeDescriptionCount, "const VkVertexInputAttributeDescription2EXT*", "pVertexAttributeDescriptions", "const VkVertexInputAttributeDescription2EXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkVertexInputAttributeDescription2EXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetMemoryZirconHandleFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetZirconHandleInfo, "const VkMemoryGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetZirconHandleInfoFUCHSIA);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pZirconHandle, "zx_handle_t*", "pZirconHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<zx_handle_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagBits(api_dump, handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<zx_handle_t>(api_dump, zirconHandle, "zx_handle_t", "zirconHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryZirconHandleProperties, "VkMemoryZirconHandlePropertiesFUCHSIA*", "pMemoryZirconHandleProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryZirconHandlePropertiesFUCHSIA);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkImportSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImportSemaphoreZirconHandleInfo, "const VkImportSemaphoreZirconHandleInfoFUCHSIA*", "pImportSemaphoreZirconHandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreZirconHandleInfoFUCHSIA);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetZirconHandleInfo, "const VkSemaphoreGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetZirconHandleInfoFUCHSIA);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pZirconHandle, "zx_handle_t*", "pZirconHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<zx_handle_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateBufferCollectionFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkBufferCollectionCreateInfoFUCHSIA*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionCreateInfoFUCHSIA);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCollection, "VkBufferCollectionFUCHSIA*", "pCollection", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionFUCHSIA);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBufferCollectionFUCHSIA(api_dump, collection, "VkBufferCollectionFUCHSIA", "collection", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pImageConstraintsInfo, "const VkImageConstraintsInfoFUCHSIA*", "pImageConstraintsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageConstraintsInfoFUCHSIA);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBufferCollectionFUCHSIA(api_dump, collection, "VkBufferCollectionFUCHSIA", "collection", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBufferConstraintsInfo, "const VkBufferConstraintsInfoFUCHSIA*", "pBufferConstraintsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferConstraintsInfoFUCHSIA);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyBufferCollectionFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBufferCollectionFUCHSIA(api_dump, collection, "VkBufferCollectionFUCHSIA", "collection", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetBufferCollectionPropertiesFUCHSIA(ApiDumpInstance& api_dump, VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBufferCollectionFUCHSIA(api_dump, collection, "VkBufferCollectionFUCHSIA", "collection", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkBufferCollectionPropertiesFUCHSIA*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionPropertiesFUCHSIA);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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 VkPipelineInfoEXT* 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 VkPipelineInfoEXT*", "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);
+void dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(ApiDumpInstance& api_dump, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkRenderPass(api_dump, renderpass, "VkRenderPass", "renderpass", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMaxWorkgroupSize, 1, "VkExtent2D*", "pMaxWorkgroupSize", "VkExtent2D", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSubpassShadingHUAWEI(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindInvocationMaskHUAWEI(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageView(api_dump, imageView, "VkImageView", "imageView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, imageLayout, "VkImageLayout", "imageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryRemoteAddressNV(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryGetRemoteAddressInfo, "const VkMemoryGetRemoteAddressInfoNV*", "pMemoryGetRemoteAddressInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetRemoteAddressInfoNV);
+        dump_separate_members(api_dump);
+        dump_type<VkRemoteAddressNV*>(api_dump, pAddress, "VkRemoteAddressNV*", "pAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelinePropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineInfo, "const VkPipelineInfoEXT*", "pPipelineInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineProperties, "VkBaseOutStructure*", "pPipelineProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBaseOutStructure);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPatchControlPointsEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, patchControlPoints, "uint32_t", "patchControlPoints", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRasterizerDiscardEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, rasterizerDiscardEnable, "VkBool32", "rasterizerDiscardEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthBiasEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthBiasEnable, "VkBool32", "depthBiasEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLogicOpEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkLogicOp(api_dump, logicOp, "VkLogicOp", "logicOp", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPrimitiveRestartEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, primitiveRestartEnable, "VkBool32", "primitiveRestartEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateScreenSurfaceQNX(ApiDumpInstance& api_dump, VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkScreenSurfaceCreateInfoQNX*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkScreenSurfaceCreateInfoQNX);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<struct _screen_window*>(api_dump, window, "struct _screen_window*", "window", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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_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);
+void dump_params_vkCmdSetColorWriteEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, attachmentCount, "uint32_t", "attachmentCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pColorWriteEnables, attachmentCount, "const VkBool32*", "pColorWriteEnables", "const VkBool32", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkBool32>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMultiEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, drawCount, "uint32_t", "drawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pVertexInfo, drawCount, "const VkMultiDrawInfoEXT*", "pVertexInfo", "const VkMultiDrawInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMultiDrawInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, instanceCount, "uint32_t", "instanceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstInstance, "uint32_t", "firstInstance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMultiIndexedEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, drawCount, "uint32_t", "drawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pIndexInfo, drawCount, "const VkMultiDrawIndexedInfoEXT*", "pIndexInfo", "const VkMultiDrawIndexedInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMultiDrawIndexedInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, instanceCount, "uint32_t", "instanceCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstInstance, "uint32_t", "firstInstance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVertexOffset, "const int32_t*", "pVertexOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const int32_t>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateMicromapEXT(ApiDumpInstance& api_dump, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkMicromapCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMicromap, "VkMicromapEXT*", "pMicromap", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyMicromapEXT(ApiDumpInstance& api_dump, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkMicromapEXT(api_dump, micromap, "VkMicromapEXT", "micromap", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBuildMicromapsEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, infoCount, "uint32_t", "infoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInfos, infoCount, "const VkMicromapBuildInfoEXT*", "pInfos", "const VkMicromapBuildInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBuildMicromapsEXT(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, infoCount, "uint32_t", "infoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInfos, infoCount, "const VkMicromapBuildInfoEXT*", "pInfos", "const VkMicromapBuildInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyMicromapEXT(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMicromapInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyMicromapToMemoryEXT(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapToMemoryInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyMemoryToMicromapEXT(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToMicromapInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWriteMicromapsPropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, micromapCount, "uint32_t", "micromapCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMicromaps, micromapCount, "const VkMicromapEXT*", "pMicromaps", "const VkMicromapEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT);
+        dump_separate_members(api_dump);
+        dump_VkQueryType(api_dump, queryType, "VkQueryType", "queryType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, stride, "size_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMicromapEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMicromapInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMicromapToMemoryEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapToMemoryInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMemoryToMicromapEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToMicromapInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteMicromapsPropertiesEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, micromapCount, "uint32_t", "micromapCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMicromaps, micromapCount, "const VkMicromapEXT*", "pMicromaps", "const VkMicromapEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT);
+        dump_separate_members(api_dump);
+        dump_VkQueryType(api_dump, queryType, "VkQueryType", "queryType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceMicromapCompatibilityEXT(ApiDumpInstance& api_dump, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVersionInfo, "const VkMicromapVersionInfoEXT*", "pVersionInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapVersionInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCompatibility, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCompatibilityKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMicromapBuildSizesEXT(ApiDumpInstance& api_dump, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureBuildTypeKHR(api_dump, buildType, "VkAccelerationStructureBuildTypeKHR", "buildType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBuildInfo, "const VkMicromapBuildInfoEXT*", "pBuildInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSizeInfo, "VkMicromapBuildSizesInfoEXT*", "pSizeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildSizesInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawClusterHUAWEI(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountX, "uint32_t", "groupCountX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountY, "uint32_t", "groupCountY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountZ, "uint32_t", "groupCountZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawClusterIndirectHUAWEI(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetDeviceMemoryPriorityEXT(ApiDumpInstance& api_dump, VkDevice device, VkDeviceMemory memory, float priority) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeviceMemory(api_dump, memory, "VkDeviceMemory", "memory", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, priority, "float", "priority", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance& api_dump, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindingReference, "const VkDescriptorSetBindingReferenceVALVE*", "pBindingReference", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetBindingReferenceVALVE);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHostMapping, "VkDescriptorSetLayoutHostMappingInfoVALVE*", "pHostMapping", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutHostMappingInfoVALVE);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDescriptorSetHostMappingVALVE(ApiDumpInstance& api_dump, VkDevice device, VkDescriptorSet descriptorSet, void** ppData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDescriptorSet(api_dump, descriptorSet, "VkDescriptorSet", "descriptorSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void**>(api_dump, ppData, "void**", "ppData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMemoryIndirectNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, copyBufferAddress, "VkDeviceAddress", "copyBufferAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, copyCount, "uint32_t", "copyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMemoryToImageIndirectNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, copyBufferAddress, "VkDeviceAddress", "copyBufferAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, copyCount, "uint32_t", "copyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImage(api_dump, dstImage, "VkImage", "dstImage", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, dstImageLayout, "VkImageLayout", "dstImageLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pImageSubresources, copyCount, "const VkImageSubresourceLayers*", "pImageSubresources", "const VkImageSubresourceLayers", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceLayers);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDecompressMemoryNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, decompressRegionCount, "uint32_t", "decompressRegionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pDecompressMemoryRegions, decompressRegionCount, "const VkDecompressMemoryRegionNV*", "pDecompressMemoryRegions", "const VkDecompressMemoryRegionNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDecompressMemoryRegionNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDecompressMemoryIndirectCountNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, indirectCommandsAddress, "VkDeviceAddress", "indirectCommandsAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, indirectCommandsCountAddress, "VkDeviceAddress", "indirectCommandsCountAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineIndirectMemoryRequirementsNV(ApiDumpInstance& api_dump, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkComputePipelineCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkComputePipelineCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdUpdatePipelineIndirectBufferNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineBindPoint(api_dump, pipelineBindPoint, "VkPipelineBindPoint", "pipelineBindPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPipelineIndirectDeviceAddressNV(ApiDumpInstance& api_dump, VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkPipelineIndirectDeviceAddressInfoNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineIndirectDeviceAddressInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetNativeBufferPropertiesOHOS(ApiDumpInstance& api_dump, VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const struct OH_NativeBuffer*>(api_dump, buffer, "const struct OH_NativeBuffer*", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkNativeBufferPropertiesOHOS*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkNativeBufferPropertiesOHOS);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryNativeBufferOHOS(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkMemoryGetNativeBufferInfoOHOS*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetNativeBufferInfoOHOS);
+        dump_separate_members(api_dump);
+        dump_type<struct OH_NativeBuffer**>(api_dump, pBuffer, "struct OH_NativeBuffer**", "pBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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_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);
+void dump_params_vkCmdSetDepthClampEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthClampEnable, "VkBool32", "depthClampEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetPolygonModeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPolygonMode(api_dump, polygonMode, "VkPolygonMode", "polygonMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRasterizationSamplesEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSampleCountFlagBits(api_dump, rasterizationSamples, "VkSampleCountFlagBits", "rasterizationSamples", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetSampleMaskEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSampleCountFlagBits(api_dump, samples, "VkSampleCountFlagBits", "samples", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pSampleMask, (samples + 31) / 32, "const VkSampleMask*", "pSampleMask", "const VkSampleMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkSampleMask>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetAlphaToCoverageEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, alphaToCoverageEnable, "VkBool32", "alphaToCoverageEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetAlphaToOneEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, alphaToOneEnable, "VkBool32", "alphaToOneEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLogicOpEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, logicOpEnable, "VkBool32", "logicOpEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetColorBlendEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstAttachment, "uint32_t", "firstAttachment", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, attachmentCount, "uint32_t", "attachmentCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pColorBlendEnables, attachmentCount, "const VkBool32*", "pColorBlendEnables", "const VkBool32", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkBool32>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetColorBlendEquationEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstAttachment, "uint32_t", "firstAttachment", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, attachmentCount, "uint32_t", "attachmentCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pColorBlendEquations, attachmentCount, "const VkColorBlendEquationEXT*", "pColorBlendEquations", "const VkColorBlendEquationEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkColorBlendEquationEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetColorWriteMaskEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstAttachment, "uint32_t", "firstAttachment", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, attachmentCount, "uint32_t", "attachmentCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pColorWriteMasks, attachmentCount, "const VkColorComponentFlags*", "pColorWriteMasks", "const VkColorComponentFlags", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkColorComponentFlags);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetTessellationDomainOriginEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkTessellationDomainOrigin(api_dump, domainOrigin, "VkTessellationDomainOrigin", "domainOrigin", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRasterizationStreamEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t rasterizationStream) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, rasterizationStream, "uint32_t", "rasterizationStream", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetConservativeRasterizationModeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkConservativeRasterizationModeEXT(api_dump, conservativeRasterizationMode, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<float>(api_dump, extraPrimitiveOverestimationSize, "float", "extraPrimitiveOverestimationSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthClipEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, depthClipEnable, "VkBool32", "depthClipEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetSampleLocationsEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, sampleLocationsEnable, "VkBool32", "sampleLocationsEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetColorBlendAdvancedEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstAttachment, "uint32_t", "firstAttachment", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, attachmentCount, "uint32_t", "attachmentCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pColorBlendAdvanced, attachmentCount, "const VkColorBlendAdvancedEXT*", "pColorBlendAdvanced", "const VkColorBlendAdvancedEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkColorBlendAdvancedEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetProvokingVertexModeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkProvokingVertexModeEXT(api_dump, provokingVertexMode, "VkProvokingVertexModeEXT", "provokingVertexMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLineRasterizationModeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkLineRasterizationMode(api_dump, lineRasterizationMode, "VkLineRasterizationModeEXT", "lineRasterizationMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetLineStippleEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, stippledLineEnable, "VkBool32", "stippledLineEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, negativeOneToOne, "VkBool32", "negativeOneToOne", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewportWScalingEnableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, viewportWScalingEnable, "VkBool32", "viewportWScalingEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetViewportSwizzleNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstViewport, "uint32_t", "firstViewport", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, viewportCount, "uint32_t", "viewportCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pViewportSwizzles, viewportCount, "const VkViewportSwizzleNV*", "pViewportSwizzles", "const VkViewportSwizzleNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkViewportSwizzleNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoverageToColorEnableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, coverageToColorEnable, "VkBool32", "coverageToColorEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoverageToColorLocationNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, coverageToColorLocation, "uint32_t", "coverageToColorLocation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoverageModulationModeNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCoverageModulationModeNV(api_dump, coverageModulationMode, "VkCoverageModulationModeNV", "coverageModulationMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoverageModulationTableEnableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, coverageModulationTableEnable, "VkBool32", "coverageModulationTableEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoverageModulationTableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, coverageModulationTableCount, "uint32_t", "coverageModulationTableCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCoverageModulationTable, coverageModulationTableCount, "const float*", "pCoverageModulationTable", "const float", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const float>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetShadingRateImageEnableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, shadingRateImageEnable, "VkBool32", "shadingRateImageEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, representativeFragmentTestEnable, "VkBool32", "representativeFragmentTestEnable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetCoverageReductionModeNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkCoverageReductionModeNV(api_dump, coverageReductionMode, "VkCoverageReductionModeNV", "coverageReductionMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateTensorARM(ApiDumpInstance& api_dump, VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkTensorCreateInfoARM*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorCreateInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTensor, "VkTensorARM*", "pTensor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyTensorARM(ApiDumpInstance& api_dump, VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkTensorARM(api_dump, tensor, "VkTensorARM", "tensor", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateTensorViewARM(ApiDumpInstance& api_dump, VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkTensorViewCreateInfoARM*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewCreateInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pView, "VkTensorViewARM*", "pView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyTensorViewARM(ApiDumpInstance& api_dump, VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkTensorViewARM(api_dump, tensorView, "VkTensorViewARM", "tensorView", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetTensorMemoryRequirementsARM(ApiDumpInstance& api_dump, VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkTensorMemoryRequirementsInfoARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorMemoryRequirementsInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindTensorMemoryARM(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindTensorMemoryInfoARM*", "pBindInfos", "const VkBindTensorMemoryInfoARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTensorMemoryInfoARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceTensorMemoryRequirementsARM(ApiDumpInstance& api_dump, VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDeviceTensorMemoryRequirementsARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceTensorMemoryRequirementsARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyTensorARM(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCopyTensorInfo, "const VkCopyTensorInfoARM*", "pCopyTensorInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyTensorInfoARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalTensorInfo, "const VkPhysicalDeviceExternalTensorInfoARM*", "pExternalTensorInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalTensorInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalTensorProperties, "VkExternalTensorPropertiesARM*", "pExternalTensorProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalTensorPropertiesARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(ApiDumpInstance& api_dump, VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkTensorCaptureDescriptorDataInfoARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorCaptureDescriptorDataInfoARM);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(ApiDumpInstance& api_dump, VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkTensorViewCaptureDescriptorDataInfoARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewCaptureDescriptorDataInfoARM);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetShaderModuleIdentifierEXT(ApiDumpInstance& api_dump, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderModule(api_dump, shaderModule, "VkShaderModule", "shaderModule", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pIdentifier, "VkShaderModuleIdentifierEXT*", "pIdentifier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleIdentifierEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(ApiDumpInstance& api_dump, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkShaderModuleCreateInfo*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleCreateInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pIdentifier, "VkShaderModuleIdentifierEXT*", "pIdentifier", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleIdentifierEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pOpticalFlowImageFormatInfo, "const VkOpticalFlowImageFormatInfoNV*", "pOpticalFlowImageFormatInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowImageFormatInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pFormatCount, "uint32_t*", "pFormatCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pImageFormatProperties, *pFormatCount, "VkOpticalFlowImageFormatPropertiesNV*", "pImageFormatProperties", "VkOpticalFlowImageFormatPropertiesNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowImageFormatPropertiesNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateOpticalFlowSessionNV(ApiDumpInstance& api_dump, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkOpticalFlowSessionCreateInfoNV*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowSessionCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSession, "VkOpticalFlowSessionNV*", "pSession", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowSessionNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyOpticalFlowSessionNV(ApiDumpInstance& api_dump, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkOpticalFlowSessionNV(api_dump, session, "VkOpticalFlowSessionNV", "session", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindOpticalFlowSessionImageNV(ApiDumpInstance& api_dump, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkOpticalFlowSessionNV(api_dump, session, "VkOpticalFlowSessionNV", "session", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkOpticalFlowSessionBindingPointNV(api_dump, bindingPoint, "VkOpticalFlowSessionBindingPointNV", "bindingPoint", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageView(api_dump, view, "VkImageView", "view", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageLayout(api_dump, layout, "VkImageLayout", "layout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdOpticalFlowExecuteNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkOpticalFlowSessionNV(api_dump, session, "VkOpticalFlowSessionNV", "session", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExecuteInfo, "const VkOpticalFlowExecuteInfoNV*", "pExecuteInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowExecuteInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkAntiLagUpdateAMD(ApiDumpInstance& api_dump, VkDevice device, const VkAntiLagDataAMD* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pData, "const VkAntiLagDataAMD*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAntiLagDataAMD);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateShadersEXT(ApiDumpInstance& api_dump, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkShaderCreateInfoEXT*", "pCreateInfos", "const VkShaderCreateInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pShaders, createInfoCount, "VkShaderEXT*", "pShaders", "VkShaderEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyShaderEXT(ApiDumpInstance& api_dump, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderEXT(api_dump, shader, "VkShaderEXT", "shader", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetShaderBinaryDataEXT(ApiDumpInstance& api_dump, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderEXT(api_dump, shader, "VkShaderEXT", "shader", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDataSize, "size_t*", "pDataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<size_t>);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBindShadersEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stageCount, "uint32_t", "stageCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pStages, stageCount, "const VkShaderStageFlagBits*", "pStages", "const VkShaderStageFlagBits", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderStageFlagBits);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pShaders, stageCount, "const VkShaderEXT*", "pShaders", "const VkShaderEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetDepthClampRangeEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDepthClampModeEXT(api_dump, depthClampMode, "VkDepthClampModeEXT", "depthClampMode", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDepthClampRange, "const VkDepthClampRangeEXT*", "pDepthClampRange", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDepthClampRangeEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetFramebufferTilePropertiesQCOM(ApiDumpInstance& api_dump, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkFramebuffer(api_dump, framebuffer, "VkFramebuffer", "framebuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertiesCount, "uint32_t*", "pPropertiesCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertiesCount, "VkTilePropertiesQCOM*", "pProperties", "VkTilePropertiesQCOM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTilePropertiesQCOM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDynamicRenderingTilePropertiesQCOM(ApiDumpInstance& api_dump, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingInfo, "const VkRenderingInfo*", "pRenderingInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkTilePropertiesQCOM*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTilePropertiesQCOM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkCooperativeVectorPropertiesNV*", "pProperties", "VkCooperativeVectorPropertiesNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeVectorPropertiesNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkConvertCooperativeVectorMatrixNV(ApiDumpInstance& api_dump, VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkConvertCooperativeVectorMatrixInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdConvertCooperativeVectorMatrixNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, infoCount, "uint32_t", "infoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInfos, infoCount, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfos", "const VkConvertCooperativeVectorMatrixInfoNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkConvertCooperativeVectorMatrixInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetLatencySleepModeNV(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSleepModeInfo, "const VkLatencySleepModeInfoNV*", "pSleepModeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkLatencySleepModeInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkLatencySleepNV(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSleepInfo, "const VkLatencySleepInfoNV*", "pSleepInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkLatencySleepInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkSetLatencyMarkerNV(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLatencyMarkerInfo, "const VkSetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSetLatencyMarkerInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetLatencyTimingsNV(ApiDumpInstance& api_dump, VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkSwapchainKHR(api_dump, swapchain, "VkSwapchainKHR", "swapchain", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pLatencyMarkerInfo, "VkGetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGetLatencyMarkerInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkQueueNotifyOutOfBandNV(ApiDumpInstance& api_dump, VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkQueue(api_dump, queue, "VkQueue", "queue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueTypeInfo, "const VkOutOfBandQueueTypeInfoNV*", "pQueueTypeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkOutOfBandQueueTypeInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDataGraphPipelinesARM(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkDataGraphPipelineCreateInfoARM*", "pCreateInfos", "const VkDataGraphPipelineCreateInfoARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineCreateInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPipelines, createInfoCount, "VkPipeline*", "pPipelines", "VkPipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateDataGraphPipelineSessionARM(ApiDumpInstance& api_dump, VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkDataGraphPipelineSessionCreateInfoARM*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionCreateInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSession, "VkDataGraphPipelineSessionARM*", "pSession", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(ApiDumpInstance& api_dump, VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDataGraphPipelineSessionBindPointRequirementsInfoARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBindPointRequirementCount, "uint32_t*", "pBindPointRequirementCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindPointRequirements, *pBindPointRequirementCount, "VkDataGraphPipelineSessionBindPointRequirementARM*", "pBindPointRequirements", "VkDataGraphPipelineSessionBindPointRequirementARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionBindPointRequirementARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(ApiDumpInstance& api_dump, VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDataGraphPipelineSessionMemoryRequirementsInfoARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBindDataGraphPipelineSessionMemoryARM(ApiDumpInstance& api_dump, VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, bindInfoCount, "uint32_t", "bindInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pBindInfos, bindInfoCount, "const VkBindDataGraphPipelineSessionMemoryInfoARM*", "pBindInfos", "const VkBindDataGraphPipelineSessionMemoryInfoARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDataGraphPipelineSessionMemoryInfoARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyDataGraphPipelineSessionARM(ApiDumpInstance& api_dump, VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDataGraphPipelineSessionARM(api_dump, session, "VkDataGraphPipelineSessionARM", "session", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDispatchDataGraphARM(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDataGraphPipelineSessionARM(api_dump, session, "VkDataGraphPipelineSessionARM", "session", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkDataGraphPipelineDispatchInfoARM*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineDispatchInfoARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(ApiDumpInstance& api_dump, VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineInfo, "const VkDataGraphPipelineInfoARM*", "pPipelineInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertiesCount, "uint32_t*", "pPropertiesCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertiesCount, "VkDataGraphPipelinePropertyARM*", "pProperties", "VkDataGraphPipelinePropertyARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelinePropertyARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDataGraphPipelinePropertiesARM(ApiDumpInstance& api_dump, VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPipelineInfo, "const VkDataGraphPipelineInfoARM*", "pPipelineInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineInfoARM);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, propertiesCount, "uint32_t", "propertiesCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, propertiesCount, "VkDataGraphPipelinePropertyQueryResultARM*", "pProperties", "VkDataGraphPipelinePropertyQueryResultARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelinePropertyQueryResultARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueFamilyDataGraphPropertyCount, "uint32_t*", "pQueueFamilyDataGraphPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pQueueFamilyDataGraphProperties, *pQueueFamilyDataGraphPropertyCount, "VkQueueFamilyDataGraphPropertiesARM*", "pQueueFamilyDataGraphProperties", "VkQueueFamilyDataGraphPropertiesARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphPropertiesARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueFamilyDataGraphProcessingEngineInfo, "const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*", "pQueueFamilyDataGraphProcessingEngineInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pQueueFamilyDataGraphProcessingEngineProperties, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM*", "pQueueFamilyDataGraphProcessingEngineProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkImageAspectFlags(api_dump, aspectMask, "VkImageAspectFlags", "aspectMask", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetScreenBufferPropertiesQNX(ApiDumpInstance& api_dump, VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const struct _screen_buffer*>(api_dump, buffer, "const struct _screen_buffer*", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pProperties, "VkScreenBufferPropertiesQNX*", "pProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkScreenBufferPropertiesQNX);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCmdBindTileMemoryQCOM(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pTileMemoryBindInfo, "const VkTileMemoryBindInfoQCOM*", "pTileMemoryBindInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkTileMemoryBindInfoQCOM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDecompressMemoryEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pDecompressMemoryInfoEXT, "const VkDecompressMemoryInfoEXT*", "pDecompressMemoryInfoEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkDecompressMemoryInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDecompressMemoryIndirectCountEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkMemoryDecompressionMethodFlagsEXT(api_dump, decompressionMethod, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, indirectCommandsAddress, "VkDeviceAddress", "indirectCommandsAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, indirectCommandsCountAddress, "VkDeviceAddress", "indirectCommandsCountAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDecompressionCount, "uint32_t", "maxDecompressionCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateExternalComputeQueueNV(ApiDumpInstance& api_dump, VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkExternalComputeQueueCreateInfoNV*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueCreateInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pExternalQueue, "VkExternalComputeQueueNV*", "pExternalQueue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyExternalComputeQueueNV(ApiDumpInstance& api_dump, VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalComputeQueueNV(api_dump, externalQueue, "VkExternalComputeQueueNV", "externalQueue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetExternalComputeQueueDataNV(ApiDumpInstance& api_dump, VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkExternalComputeQueueNV(api_dump, externalQueue, "VkExternalComputeQueueNV", "externalQueue", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, params, "VkExternalComputeQueueDataParamsNV*", "params", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueDataParamsNV);
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetClusterAccelerationStructureBuildSizesNV(ApiDumpInstance& api_dump, VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkClusterAccelerationStructureInputInfoNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkClusterAccelerationStructureInputInfoNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSizeInfo, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCommandInfos, "const VkClusterAccelerationStructureCommandsInfoNV*", "pCommandInfos", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkClusterAccelerationStructureCommandsInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(ApiDumpInstance& api_dump, VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkPartitionedAccelerationStructureInstancesInputNV*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPartitionedAccelerationStructureInstancesInputNV);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSizeInfo, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBuildInfo, "const VkBuildPartitionedAccelerationStructureInfoNV*", "pBuildInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBuildPartitionedAccelerationStructureInfoNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(ApiDumpInstance& api_dump, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkGeneratedCommandsMemoryRequirementsInfoEXT*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsMemoryRequirementsInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryRequirements, "VkMemoryRequirements2*", "pMemoryRequirements", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdPreprocessGeneratedCommandsEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGeneratedCommandsInfo, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoEXT);
+        dump_separate_members(api_dump);
+        dump_VkCommandBuffer(api_dump, stateCommandBuffer, "VkCommandBuffer", "stateCommandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdExecuteGeneratedCommandsEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkBool32>(api_dump, isPreprocessed, "VkBool32", "isPreprocessed", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGeneratedCommandsInfo, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateIndirectCommandsLayoutEXT(ApiDumpInstance& api_dump, VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkIndirectCommandsLayoutCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pIndirectCommandsLayout, "VkIndirectCommandsLayoutEXT*", "pIndirectCommandsLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyIndirectCommandsLayoutEXT(ApiDumpInstance& api_dump, VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndirectCommandsLayoutEXT(api_dump, indirectCommandsLayout, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateIndirectExecutionSetEXT(ApiDumpInstance& api_dump, VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkIndirectExecutionSetCreateInfoEXT*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectExecutionSetCreateInfoEXT);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pIndirectExecutionSet, "VkIndirectExecutionSetEXT*", "pIndirectExecutionSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectExecutionSetEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyIndirectExecutionSetEXT(ApiDumpInstance& api_dump, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndirectExecutionSetEXT(api_dump, indirectExecutionSet, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUpdateIndirectExecutionSetPipelineEXT(ApiDumpInstance& api_dump, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndirectExecutionSetEXT(api_dump, indirectExecutionSet, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, executionSetWriteCount, "uint32_t", "executionSetWriteCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pExecutionSetWrites, executionSetWriteCount, "const VkWriteIndirectExecutionSetPipelineEXT*", "pExecutionSetWrites", "const VkWriteIndirectExecutionSetPipelineEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteIndirectExecutionSetPipelineEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkUpdateIndirectExecutionSetShaderEXT(ApiDumpInstance& api_dump, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkIndirectExecutionSetEXT(api_dump, indirectExecutionSet, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, executionSetWriteCount, "uint32_t", "executionSetWriteCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pExecutionSetWrites, executionSetWriteCount, "const VkWriteIndirectExecutionSetShaderEXT*", "pExecutionSetWrites", "const VkWriteIndirectExecutionSetShaderEXT", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteIndirectExecutionSetShaderEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkCreateSurfaceOHOS(ApiDumpInstance& api_dump, VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkInstance(api_dump, instance, "VkInstance", "instance", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkSurfaceCreateInfoOHOS*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCreateInfoOHOS);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSurface, "VkSurfaceKHR*", "pSurface", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pPropertyCount, "uint32_t*", "pPropertyCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pProperties, *pPropertyCount, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV*", "pProperties", "VkCooperativeMatrixFlexibleDimensionsPropertiesNV", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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);
+void dump_params_vkGetMemoryMetalHandleEXT(ApiDumpInstance& api_dump, VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pGetMetalHandleInfo, "const VkMemoryGetMetalHandleInfoEXT*", "pGetMetalHandleInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetMetalHandleInfoEXT);
+        dump_separate_members(api_dump);
+        dump_type<void**>(api_dump, pHandle, "void**", "pHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetMemoryMetalHandlePropertiesEXT(ApiDumpInstance& api_dump, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkExternalMemoryHandleTypeFlagBits(api_dump, handleType, "VkExternalMemoryHandleTypeFlagBits", "handleType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<const void*>(api_dump, pHandle, "const void*", "pHandle", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMemoryMetalHandleProperties, "VkMemoryMetalHandlePropertiesEXT*", "pMemoryMetalHandleProperties", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMetalHandlePropertiesEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 #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_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_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);
-    }
-}
-
-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);
+void dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(ApiDumpInstance& api_dump, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkPhysicalDevice(api_dump, physicalDevice, "VkPhysicalDevice", "physicalDevice", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, queueFamilyIndex, "uint32_t", "queueFamilyIndex", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCounterCount, "uint32_t*", "pCounterCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounters, *pCounterCount, "VkPerformanceCounterARM*", "pCounters", "VkPerformanceCounterARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterARM);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCounterDescriptions, *pCounterCount, "VkPerformanceCounterDescriptionARM*", "pCounterDescriptions", "VkPerformanceCounterDescriptionARM", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterDescriptionARM);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdEndRendering2EXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRenderingEndInfo, "const VkRenderingEndInfoKHR*", "pRenderingEndInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingEndInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBeginCustomResolveEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBeginCustomResolveInfo, "const VkBeginCustomResolveInfoEXT*", "pBeginCustomResolveInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkBeginCustomResolveInfoEXT);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetComputeOccupancyPriorityNV(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pParameters, "const VkComputeOccupancyPriorityParametersNV*", "pParameters", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkComputeOccupancyPriorityParametersNV);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateAccelerationStructureKHR(ApiDumpInstance& api_dump, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCreateInfo, "const VkAccelerationStructureCreateInfoKHR*", "pCreateInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAccelerationStructure, "VkAccelerationStructureKHR*", "pAccelerationStructure", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkDestroyAccelerationStructureKHR(ApiDumpInstance& api_dump, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureKHR(api_dump, accelerationStructure, "VkAccelerationStructureKHR", "accelerationStructure", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBuildAccelerationStructuresKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, infoCount, "uint32_t", "infoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInfos, infoCount, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR);
+        dump_separate_members(api_dump);
+        dump_double_pointer_array(api_dump, ppBuildRangeInfos, infoCount, "const VkAccelerationStructureBuildRangeInfoKHR* const*", "ppBuildRangeInfos", "const VkAccelerationStructureBuildRangeInfoKHR*", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildRangeInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, infoCount, "uint32_t", "infoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInfos, infoCount, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pIndirectDeviceAddresses, infoCount, "const VkDeviceAddress*", "pIndirectDeviceAddresses", "const VkDeviceAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const VkDeviceAddress>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pIndirectStrides, infoCount, "const uint32_t*", "pIndirectStrides", "const uint32_t", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, ppMaxPrimitiveCounts, infoCount, "const uint32_t* const*", "ppMaxPrimitiveCounts", "const uint32_t*", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const uint32_t*>);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkBuildAccelerationStructuresKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, infoCount, "uint32_t", "infoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pInfos, infoCount, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR);
+        dump_separate_members(api_dump);
+        dump_double_pointer_array(api_dump, ppBuildRangeInfos, infoCount, "const VkAccelerationStructureBuildRangeInfoKHR* const*", "ppBuildRangeInfos", "const VkAccelerationStructureBuildRangeInfoKHR*", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildRangeInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyAccelerationStructureKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureToMemoryInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToAccelerationStructureInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& api_dump, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, accelerationStructureCount, "uint32_t", "accelerationStructureCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pAccelerationStructures, accelerationStructureCount, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR);
+        dump_separate_members(api_dump);
+        dump_VkQueryType(api_dump, queryType, "VkQueryType", "queryType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, stride, "size_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyAccelerationStructureKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureToMemoryInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToAccelerationStructureInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetAccelerationStructureDeviceAddressKHR(ApiDumpInstance& api_dump, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pInfo, "const VkAccelerationStructureDeviceAddressInfoKHR*", "pInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureDeviceAddressInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, accelerationStructureCount, "uint32_t", "accelerationStructureCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pAccelerationStructures, accelerationStructureCount, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR);
+        dump_separate_members(api_dump);
+        dump_VkQueryType(api_dump, queryType, "VkQueryType", "queryType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkQueryPool(api_dump, queryPool, "VkQueryPool", "queryPool", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstQuery, "uint32_t", "firstQuery", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(ApiDumpInstance& api_dump, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pVersionInfo, "const VkAccelerationStructureVersionInfoKHR*", "pVersionInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureVersionInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCompatibility, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCompatibilityKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetAccelerationStructureBuildSizesKHR(ApiDumpInstance& api_dump, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkAccelerationStructureBuildTypeKHR(api_dump, buildType, "VkAccelerationStructureBuildTypeKHR", "buildType", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pBuildInfo, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pBuildInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pMaxPrimitiveCounts, pBuildInfo->geometryCount, "const uint32_t*", "pMaxPrimitiveCounts", "const uint32_t", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_type<const uint32_t>);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pSizeInfo, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdTraceRaysKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRaygenShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMissShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHitShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCallableShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, width, "uint32_t", "width", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, height, "uint32_t", "height", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, depth, "uint32_t", "depth", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCreateRayTracingPipelinesKHR(ApiDumpInstance& api_dump, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkDeferredOperationKHR(api_dump, deferredOperation, "VkDeferredOperationKHR", "deferredOperation", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipelineCache(api_dump, pipelineCache, "VkPipelineCache", "pipelineCache", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, createInfoCount, "uint32_t", "createInfoCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pCreateInfos, createInfoCount, "const VkRayTracingPipelineCreateInfoKHR*", "pCreateInfos", "const VkRayTracingPipelineCreateInfoKHR", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkRayTracingPipelineCreateInfoKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pAllocator, "const VkAllocationCallbacks*", "pAllocator", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks);
+        dump_separate_members(api_dump);
+        dump_pointer_array(api_dump, pPipelines, createInfoCount, "VkPipeline*", "pPipelines", "VkPipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline);
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, firstGroup, "uint32_t", "firstGroup", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCount, "uint32_t", "groupCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<size_t>(api_dump, dataSize, "size_t", "dataSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<void*>(api_dump, pData, "void*", "pData", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdTraceRaysIndirectKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pRaygenShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pMissShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pHitShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_pointer(api_dump, pCallableShaderBindingTable, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR);
+        dump_separate_members(api_dump);
+        dump_type_hex<VkDeviceAddress>(api_dump, indirectDeviceAddress, "VkDeviceAddress", "indirectDeviceAddress", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkGetRayTracingShaderGroupStackSizeKHR(ApiDumpInstance& api_dump, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkDevice(api_dump, device, "VkDevice", "device", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkPipeline(api_dump, pipeline, "VkPipeline", "pipeline", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, group, "uint32_t", "group", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkShaderGroupShaderKHR(api_dump, groupShader, "VkShaderGroupShaderKHR", "groupShader", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, pipelineStackSize, "uint32_t", "pipelineStackSize", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMeshTasksEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountX, "uint32_t", "groupCountX", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountY, "uint32_t", "groupCountY", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, groupCountZ, "uint32_t", "groupCountZ", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMeshTasksIndirectEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, drawCount, "uint32_t", "drawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
+    }
+}
+
+void dump_params_vkCmdDrawMeshTasksIndirectCountEXT(ApiDumpInstance& api_dump, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    if (api_dump.settings().showParams()) {
+        dump_pre_params_formatting(api_dump);
+        dump_VkCommandBuffer(api_dump, commandBuffer, "VkCommandBuffer", "commandBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, buffer, "VkBuffer", "buffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, offset, "VkDeviceSize", "offset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_VkBuffer(api_dump, countBuffer, "VkBuffer", "countBuffer", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<VkDeviceSize>(api_dump, countBufferOffset, "VkDeviceSize", "countBufferOffset", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, maxDrawCount, "uint32_t", "maxDrawCount", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_separate_members(api_dump);
+        dump_type<uint32_t>(api_dump, stride, "uint32_t", "stride", (api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1));
+        dump_post_params_formatting(api_dump);
+        api_dump.settings().flush();
     }
 }
 
 //========================== 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));
+void dump_return_value_VkDeviceAddress(ApiDumpInstance& api_dump, const VkDeviceAddress& address) {
+    dump_value_hex(api_dump, static_cast<uint64_t>(address));
 }
diff --git a/scripts/generators/api_dump_generator.py b/scripts/generators/api_dump_generator.py
index 10e81dcf13..39c2cb743a 100644
--- a/scripts/generators/api_dump_generator.py
+++ b/scripts/generators/api_dump_generator.py
@@ -23,70 +23,70 @@
 TRACKED_STATE = {
     'vkAllocateCommandBuffers':
         'if(result == VK_SUCCESS)\n' +
-            'ApiDumpInstance::current().addCmdBuffers(\n' +
+            'api_dump.addCmdBuffers(\n' +
                 'device,\n' +
                 'pAllocateInfo->commandPool,\n' +
                 'std::vector<VkCommandBuffer>(pCommandBuffers, pCommandBuffers + pAllocateInfo->commandBufferCount),\n' +
                 'pAllocateInfo->level\n'
             ');',
     'vkDestroyCommandPool':
-        'ApiDumpInstance::current().eraseCmdBufferPool(device, commandPool);'
+        'api_dump.eraseCmdBufferPool(device, commandPool);'
     ,
     'vkFreeCommandBuffers':
-        'ApiDumpInstance::current().eraseCmdBuffers(device, commandPool, std::vector<VkCommandBuffer>(pCommandBuffers, pCommandBuffers + commandBufferCount));'
+        'api_dump.eraseCmdBuffers(device, commandPool, std::vector<VkCommandBuffer>(pCommandBuffers, pCommandBuffers + commandBufferCount));'
     ,
 }
 
 PARAMETER_STATE = {
     'pDynamicState': {
         'VkGraphicsPipelineCreateInfo':
-            'ApiDumpInstance::current().setIsDynamicViewport('
+            'api_dump.setIsDynamicViewport('
             'object.pDynamicState && '
             'std::count('
                 'object.pDynamicState->pDynamicStates, '
                 'object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, '
                 'VK_DYNAMIC_STATE_VIEWPORT'
             ') > 0);'
-            'ApiDumpInstance::current().setIsDynamicScissor('
+            'api_dump.setIsDynamicScissor('
             'object.pDynamicState && '
             'std::count('
                 'object.pDynamicState->pDynamicStates, '
                 'object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, '
                 'VK_DYNAMIC_STATE_SCISSOR'
             '));'
-            'ApiDumpInstance::current().setIsGPLPreRasterOrFragmentShader(checkForGPLPreRasterOrFragmentShader(object));',
+            'api_dump.setIsGPLPreRasterOrFragmentShader(checkForGPLPreRasterOrFragmentShader(object));',
     },
     'commandBuffer': {
         'vkBeginCommandBuffer':
-            'ApiDumpInstance::current().setCmdBuffer(commandBuffer);',
+            'api_dump.setCmdBuffer(commandBuffer);',
     },
     'memoryProperties': {
         'VkPhysicalDeviceMemoryProperties2':
-            'ApiDumpInstance::current().setMemoryHeapCount(object.memoryProperties.memoryHeapCount);',
+            'api_dump.setMemoryHeapCount(object.memoryProperties.memoryHeapCount);',
     },
     'type': {
         'VkDescriptorGetInfoEXT':
-            'ApiDumpInstance::current().setDescriptorType(object.type);',
+            'api_dump.setDescriptorType(object.type);',
         'VkResourceDescriptorInfoEXT':
-            'ApiDumpInstance::current().setDescriptorType(object.type);',
+            'api_dump.setDescriptorType(object.type);',
         'VkIndirectExecutionSetInfoEXT':
-            'ApiDumpInstance::current().setIndirectExecutionSetInfoType(object.type);',
+            'api_dump.setIndirectExecutionSetInfoType(object.type);',
         'VkIndirectCommandsLayoutTokenEXT':
-            'ApiDumpInstance::current().setIndirectCommandsLayoutToken(object.type);',
+            'api_dump.setIndirectCommandsLayoutToken(object.type);',
     },
     'source': {
         'VkDescriptorSetAndBindingMappingEXT':
-            'ApiDumpInstance::current().setDescriptorMappingSource(object.source);',
+            'api_dump.setDescriptorMappingSource(object.source);',
     },
     'sps_max_sub_layers_minus1':{
         'StdVideoH265SequenceParameterSet':
-            'ApiDumpInstance::current().setSpsMaxSubLayersMinus1(object.sps_max_sub_layers_minus1);'
-            'ApiDumpInstance::current().setIsInVps(false);',
+            'api_dump.setSpsMaxSubLayersMinus1(object.sps_max_sub_layers_minus1);'
+            'api_dump.setIsInVps(false);',
     },
     'vps_max_sub_layers_minus1':{
         'StdVideoH265VideoParameterSet':
-            'ApiDumpInstance::current().setVpsMaxSubLayersMinus1(object.vps_max_sub_layers_minus1);'
-            'ApiDumpInstance::current().setIsInVps(true);',
+            'api_dump.setVpsMaxSubLayersMinus1(object.vps_max_sub_layers_minus1);'
+            'api_dump.setIsInVps(true);',
     },
 }
 
@@ -96,7 +96,7 @@
     },
     'VkCommandBufferBeginInfo': {
         # Tracked state ApiDumpInstance, and inherited cmd_buffer
-        'pInheritanceInfo': 'ApiDumpInstance::current().getCmdBufferLevel() == VK_COMMAND_BUFFER_LEVEL_SECONDARY',
+        'pInheritanceInfo': 'api_dump.getCmdBufferLevel() == VK_COMMAND_BUFFER_LEVEL_SECONDARY',
     },
     'VkDescriptorSetLayoutBinding': {
         'pImmutableSamplers':
@@ -107,8 +107,8 @@
         'pQueueFamilyIndices': 'object.sharingMode == VK_SHARING_MODE_CONCURRENT',
     },
     'VkPipelineViewportStateCreateInfo': {
-        'pViewports': '!ApiDumpInstance::current().getIsDynamicViewport()', # Inherited state variable is_dynamic_viewport
-        'pScissors': '!ApiDumpInstance::current().getIsDynamicScissor()',   # Inherited state variable is_dynamic_scissor
+        'pViewports': '!api_dump.getIsDynamicViewport()', # Inherited state variable is_dynamic_viewport
+        'pScissors': '!api_dump.getIsDynamicScissor()',   # Inherited state variable is_dynamic_scissor
     },
     'VkSwapchainCreateInfoKHR': {
         'pQueueFamilyIndices': 'object.imageSharingMode == VK_SHARING_MODE_CONCURRENT',
@@ -130,51 +130,51 @@
             '(object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)',
     },
     'VkDescriptorDataEXT':{
-        'pSampler': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLER',
-        'pCombinedImageSampler': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER',
-        'pInputAttachmentImage': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT',
-        'pSampledImage': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE',
-        'pStorageImage': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE',
-        'pUniformTexelBuffer': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER',
-        'pStorageTexelBuffer': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER',
-        'pUniformBuffer': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER',
-        'pStorageBuffer': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER',
-        'accelerationStructure': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR',
+        'pSampler': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLER',
+        'pCombinedImageSampler': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER',
+        'pInputAttachmentImage': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT',
+        'pSampledImage': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE',
+        'pStorageImage': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE',
+        'pUniformTexelBuffer': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER',
+        'pStorageTexelBuffer': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER',
+        'pUniformBuffer': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER',
+        'pStorageBuffer': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER',
+        'accelerationStructure': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR',
     },
     'VkResourceDescriptorDataEXT':{
-        'pImage': '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',
-        'pTexelBuffer': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER',
-        'pAddressRange': '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',
-        'pTensorARM': 'ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_TENSOR_ARM',
+        'pImage': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT',
+        'pTexelBuffer': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER',
+        'pAddressRange': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV || api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV',
+        'pTensorARM': 'api_dump.getDescriptorType() == VK_DESCRIPTOR_TYPE_TENSOR_ARM',
     },
     'VkDescriptorMappingSourceDataEXT':{
-        'constantOffset' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT',
-        'pushIndex' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT',
-        'indirectIndex' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT',
-        'indirectIndexArray' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT',
-        'heapData' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT',
-        'pushDataOffset' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT',
-        'pushAddressOffset' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT',
-        'indirectAddress' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT',
-        'shaderRecordIndex' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT',
-        'shaderRecordDataOffset' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT',
-        'shaderRecordAddressOffset' : 'ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT',
+        'constantOffset' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT',
+        'pushIndex' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT',
+        'indirectIndex' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT',
+        'indirectIndexArray' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT',
+        'heapData' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT',
+        'pushDataOffset' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT',
+        'pushAddressOffset' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT',
+        'indirectAddress' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT',
+        'shaderRecordIndex' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT',
+        'shaderRecordDataOffset' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT',
+        'shaderRecordAddressOffset' : 'api_dump.getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT',
     },
     'VkPipelineRenderingCreateInfo': {
-        'colorAttachmentCount': '!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()',
-        'pColorAttachmentFormats': '!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()',
-        'depthAttachmentFormat': '!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()',
-        'stencilAttachmentFormat': '!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()',
+        'colorAttachmentCount': '!api_dump.getIsGPLPreRasterOrFragmentShader()',
+        'pColorAttachmentFormats': '!api_dump.getIsGPLPreRasterOrFragmentShader()',
+        'depthAttachmentFormat': '!api_dump.getIsGPLPreRasterOrFragmentShader()',
+        'stencilAttachmentFormat': '!api_dump.getIsGPLPreRasterOrFragmentShader()',
     },
     'VkIndirectExecutionSetInfoEXT':{
-        'pPipelineInfo': 'ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT',
-        'pShaderInfo': 'ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT',
+        'pPipelineInfo': 'api_dump.getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT',
+        'pShaderInfo': 'api_dump.getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT',
     },
     'VkIndirectCommandsTokenDataEXT':{
-        'pPushConstant': 'ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT',
-        'pVertexBuffer': 'ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT',
-        'pIndexBuffer': 'ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT',
-        'pExecutionSet': 'ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT',
+        'pPushConstant': 'api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT',
+        'pVertexBuffer': 'api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT',
+        'pIndexBuffer': 'api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT',
+        'pExecutionSet': 'api_dump.getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT',
     },
     'StdVideoH265HrdParameters':{
         'pSubLayerHrdParametersNal': 'object.flags.nal_hrd_parameters_present_flag == 1',
@@ -184,12 +184,12 @@
 
 SPECIAL_LENGTH = {
     'VkPhysicalDeviceMemoryBudgetPropertiesEXT': {
-        'heapBudget': 'ApiDumpInstance::current().getMemoryHeapCount()',
-        'heapUsage': 'ApiDumpInstance::current().getMemoryHeapCount()',
+        'heapBudget': 'api_dump.getMemoryHeapCount()',
+        'heapUsage': 'api_dump.getMemoryHeapCount()',
     },
     'StdVideoH265HrdParameters':{
-        'pSubLayerHrdParametersNal':'ApiDumpInstance::current().getIsInVps() ? ApiDumpInstance::current().getVpsMaxSubLayersMinus1() : ApiDumpInstance::current().getSpsMaxSubLayersMinus1()',
-        'pSubLayerHrdParametersVcl':'ApiDumpInstance::current().getIsInVps() ? ApiDumpInstance::current().getVpsMaxSubLayersMinus1() : ApiDumpInstance::current().getSpsMaxSubLayersMinus1()',
+        'pSubLayerHrdParametersNal':'api_dump.getIsInVps() ? api_dump.getVpsMaxSubLayersMinus1() : api_dump.getSpsMaxSubLayersMinus1()',
+        'pSubLayerHrdParametersVcl':'api_dump.getIsInVps() ? api_dump.getVpsMaxSubLayersMinus1() : api_dump.getSpsMaxSubLayersMinus1()',
     }
 }
 
@@ -313,7 +313,7 @@ def get_fixed_array_length(fixed_length, var, parent):
 
     # Special case due to the length being non-constant non-local
     if parent.name == 'VkPhysicalDeviceMemoryBudgetPropertiesEXT' and var.name in ['heapBudget', 'heapUsage']:
-        return f'std::min(ApiDumpInstance::current().getMemoryHeapCount(), {fixed_length})'
+        return f'std::min(api_dump.getMemoryHeapCount(), {fixed_length})'
 
     if lengthIsMember:
         object_access = 'object.' if isinstance(parent, Struct) else ''
@@ -378,17 +378,17 @@ def generate_dispatch_codegen(self):
             if command.name in HANDWRITTEN_FUNCTIONS:
                 continue
             protect.add_guard(self, command.protect)
-            self.write('template<ApiDumpFormat Format>')
             self.write(f'VKAPI_ATTR {command.returnType} VKAPI_CALL {command.name}({command_param_declaration_text(command)})')
             self.write('{')
             if command.name not in BLOCKING_API_CALLS:
                 self.write(f'''
-                    std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());
-                    dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");
-                     if constexpr (Format == ApiDumpFormat::Text) {{
-                        if(ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {{
-                            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-                            dump_params_{command.name}<Format>(ApiDumpInstance::current(), {command_param_usage_text(command)});
+                    auto& api_dump = ApiDumpInstance::current();
+                    std::lock_guard<std::mutex> lg(api_dump.outputMutex());
+                    dump_function_head(api_dump, "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");
+                     if (api_dump.settings().format() == ApiDumpFormat::Text) {{
+                        if(api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {{
+                            dump_before_pre_dump_formatting(api_dump);
+                            dump_params_{command.name}(api_dump, {command_param_usage_text(command)});
                         }}
                     }}''')
 
@@ -415,8 +415,8 @@ def generate_dispatch_codegen(self):
             return_str = f'{command.returnType} result = ' if command.returnType != 'void' else ''
             self.write(f'{return_str}instance_dispatch_table({command.params[0].name})->{command.name[2:]}({command_param_usage_text(command)});')
             if command.name in BLOCKING_API_CALLS:
-                self.write('std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());')
-                self.write(f'dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");')
+                self.write('std::lock_guard<std::mutex> lg(api_dump.outputMutex());')
+                self.write(f'dump_function_head(api_dump, "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");')
 
             if command.name in TRACKED_STATE:
                 self.write(TRACKED_STATE[command.name])
@@ -425,7 +425,7 @@ def generate_dispatch_codegen(self):
                 self.write('''
                     if (pPhysicalDeviceCount != nullptr && pPhysicalDevices != nullptr) {
                         for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
-                            ApiDumpInstance::current().set_vk_instance(pPhysicalDevices[i], instance);
+                            api_dump.set_vk_instance(pPhysicalDevices[i], instance);
                         }
                     }''')
 
@@ -438,16 +438,16 @@ def generate_dispatch_codegen(self):
                 self.write('}\n')
                 self.write('(*pToolCount)++;')
 
-            self.write('if (ApiDumpInstance::current().shouldDumpOutput()) {')
+            self.write('if (api_dump.shouldDumpOutput()) {')
             if command.returnType != 'void':
                 if self.get_unaliased_type(command.returnType) in self.vulkan_defined_types:
-                    self.write(f'dump_return_value<Format>(ApiDumpInstance::current().settings(), "{command.returnType}", result, dump_return_value_{command.returnType}<Format>);')
+                    self.write(f'dump_return_value(api_dump, "{command.returnType}", result, dump_return_value_{command.returnType});')
                 else:
-                    self.write(f'dump_return_value<Format>(ApiDumpInstance::current().settings(), "{command.returnType}", result);')
-            self.write(f'''dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-                dump_params_{command.name}<Format>(ApiDumpInstance::current(), {command_param_usage_text(command)});
-                dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-                flush(ApiDumpInstance::current().settings());
+                    self.write(f'dump_return_value(api_dump, "{command.returnType}", result);')
+            self.write(f'''dump_pre_function_formatting(api_dump);
+                dump_params_{command.name}(api_dump, {command_param_usage_text(command)});
+                dump_post_function_formatting(api_dump);
+                api_dump.settings().flush();
             }}''')
             if command.returnType != 'void':
                 self.write('return result;')
@@ -462,28 +462,28 @@ def generate_dispatch_codegen(self):
 
             protect.add_guard(self, command.protect)
 
-            self.write('template<ApiDumpFormat Format>')
             self.write(f'VKAPI_ATTR {command.returnType} VKAPI_CALL {command.name}({command_param_declaration_text(command)})')
             self.write('{')
+            self.write('auto& api_dump = ApiDumpInstance::current();')
 
             if command.name not in BLOCKING_API_CALLS:
-                self.write('std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());')
+                self.write('std::lock_guard<std::mutex> lg(api_dump.outputMutex());')
                 if command.name in ['vkDebugMarkerSetObjectNameEXT', 'vkSetDebugUtilsObjectNameEXT']:
-                    self.write('ApiDumpInstance::current().update_object_name_map(pNameInfo);')
+                    self.write('api_dump.update_object_name_map(pNameInfo);')
                 self.write(f'''
-                    dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");
-                    if constexpr (Format == ApiDumpFormat::Text) {{
-                        if(ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {{
-                            dump_before_pre_dump_formatting<Format>(ApiDumpInstance::current().settings());
-                            dump_params_{command.name}<Format>(ApiDumpInstance::current(), {command_param_usage_text(command)});
+                    dump_function_head(api_dump, "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");
+                    if (api_dump.settings().format() == ApiDumpFormat::Text) {{
+                        if(api_dump.settings().shouldPreDump() && api_dump.shouldDumpOutput()) {{
+                            dump_before_pre_dump_formatting(api_dump);
+                            dump_params_{command.name}(api_dump, {command_param_usage_text(command)});
                         }}
                     }}''')
 
             return_str = f'{command.returnType} result = ' if command.returnType != 'void' else ''
             self.write(f'{return_str}device_dispatch_table({command.params[0].name})->{command.name[2:]}({command_param_usage_text(command)});')
             if command.name in BLOCKING_API_CALLS:
-                self.write('std::lock_guard<std::mutex> lg(ApiDumpInstance::current().outputMutex());')
-                self.write(f'dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");')
+                self.write('std::lock_guard<std::mutex> lg(api_dump.outputMutex());')
+                self.write(f'dump_function_head(api_dump, "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");')
 
             if command.name in TRACKED_STATE:
                 self.write('' + TRACKED_STATE[command.name])
@@ -491,28 +491,27 @@ def generate_dispatch_codegen(self):
             if command.name == 'vkDestroyDevice':
                 self.write('destroy_device_dispatch_table(get_dispatch_key(device));')
 
-            self.write('if (ApiDumpInstance::current().shouldDumpOutput()) {')
+            self.write('if (api_dump.shouldDumpOutput()) {')
             if command.returnType != 'void':
                 return_type = self.get_unaliased_type(command.returnType)
                 if return_type in self.vulkan_defined_types or return_type == 'VkDeviceAddress':
-                    self.write(f'dump_return_value<Format>(ApiDumpInstance::current().settings(), "{command.returnType}", result, dump_return_value_{command.returnType}<Format>);')
+                    self.write(f'dump_return_value(api_dump, "{command.returnType}", result, dump_return_value_{command.returnType});')
                 else:
-                    self.write(f'dump_return_value<Format>(ApiDumpInstance::current().settings(), "{command.returnType}", result);')
+                    self.write(f'dump_return_value(api_dump, "{command.returnType}", result);')
 
-            self.write(f'''dump_pre_function_formatting<Format>(ApiDumpInstance::current().settings());
-                dump_params_{command.name}<Format>(ApiDumpInstance::current(), {command_param_usage_text(command)});
-                dump_post_function_formatting<Format>(ApiDumpInstance::current().settings());
-                flush(ApiDumpInstance::current().settings());
+            self.write(f'''dump_pre_function_formatting(api_dump);
+                dump_params_{command.name}(api_dump, {command_param_usage_text(command)});
+                dump_post_function_formatting(api_dump);
+                api_dump.settings().flush();
             }}''')
 
             if command.name == 'vkQueuePresentKHR':
-                self.write('ApiDumpInstance::current().nextFrame();')
+                self.write('api_dump.nextFrame();')
             if command.returnType != 'void':
                 self.write('return result;')
             self.write('}')
         protect.add_guard(self, None)
 
-        self.write('\ntemplate<ApiDumpFormat Format>')
         self.write('VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_instance_functions(VkInstance instance, const char* pName)')
         self.write('{\n')
         for command in self.vk.commands.values():
@@ -523,12 +522,11 @@ def generate_dispatch_codegen(self):
             if command.name in NON_TEMPLATEDTED_FUNCTIONS:
                 self.write(f'return reinterpret_cast<PFN_vkVoidFunction>({command.name});')
             else:
-                self.write(f'return reinterpret_cast<PFN_vkVoidFunction>({command.name}<Format>);')
+                self.write(f'return reinterpret_cast<PFN_vkVoidFunction>({command.name});')
         protect.add_guard(self, None)
         self.write('\n    return nullptr;')
         self.write('}')
 
-        self.write('\ntemplate<ApiDumpFormat Format>')
         self.write('VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_device_functions(VkDevice device, const char* pName)')
         self.write('{\n')
         for command in [x for x in self.vk.commands.values() if x.device ]:
@@ -537,7 +535,7 @@ def generate_dispatch_codegen(self):
             if command.name in NON_TEMPLATEDTED_FUNCTIONS:
                 self.write(f'return reinterpret_cast<PFN_vkVoidFunction>({command.name});')
             else:
-                self.write(f'return reinterpret_cast<PFN_vkVoidFunction>({command.name}<Format>);')
+                self.write(f'return reinterpret_cast<PFN_vkVoidFunction>({command.name});')
         protect.add_guard(self, None)
 
         self.write('\n    return nullptr;')
@@ -547,19 +545,17 @@ def generate_enums(self, enums, protect):
         for enum in enums.values():
             protect.add_guard(self, enum.protect)
             if enum.name in self.return_types:
-                self.write('template <ApiDumpFormat Format>')
-                self.write(f'void dump_return_value_{enum.name}(const {enum.name}& object, const ApiDumpSettings& settings) {{')
+                self.write(f'void dump_return_value_{enum.name}(ApiDumpInstance& api_dump, const {enum.name}& object) {{')
                 self.write_enum_contents(enum)
                 self.write('}')
-            self.write('template <ApiDumpFormat Format>')
-            self.write(f'void dump_{enum.name}(const {enum.name} object, const ApiDumpSettings& settings, const char* type_name, const char *var_name, int indents, const void* address = nullptr)')
+            self.write(f'void dump_{enum.name}(ApiDumpInstance& api_dump, const {enum.name} object, const char* type_name, const char *var_name, int indents, const void* address = nullptr)')
             self.write('{')
-            self.write('dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);')
+            self.write('dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);')
             if enum.name in self.return_types:
-                self.write(f'dump_return_value_{enum.name}<Format>(object, settings);')
+                self.write(f'dump_return_value_{enum.name}(api_dump, object);')
             else:
                 self.write_enum_contents(enum)
-            self.write('dump_end<Format>(settings, OutputConstruct::value, indents);')
+            self.write('dump_end(api_dump, OutputConstruct::value, indents);')
             self.write('}')
         protect.add_guard(self, None)
 
@@ -567,10 +563,9 @@ def generate_structs(self, structs, protect):
         for struct in structs.values():
             protect.add_guard(self, struct.protect)
 
-            self.write('template <ApiDumpFormat Format>')
-            self.write(f'void dump_{struct.name}(const {struct.name}& object, const ApiDumpSettings& settings, const char* type_name, const char *var_name, int indents, const void* address = nullptr)')
+            self.write(f'void dump_{struct.name}(ApiDumpInstance& api_dump, const {struct.name}& object, const char* type_name, const char *var_name, int indents, const void* address = nullptr)')
             self.write('{')
-            self.write(f'dump_start<Format>(settings, OutputConstruct::{"api_union" if struct.union else "api_struct"}, type_name, var_name, indents, address);')
+            self.write(f'dump_start(api_dump, OutputConstruct::{"api_union" if struct.union else "api_struct"}, type_name, var_name, indents, address);')
 
             for member in struct.members:
                 validity_check = self.get_validity_check(member, struct)
@@ -587,7 +582,7 @@ def generate_structs(self, structs, protect):
                 custom_fullType = get_fulltype(member)
                 validity_check = self.get_validity_check(member, struct)
                 if member != struct.members[0]:
-                    self.write('dump_separate_members<Format>(settings);')
+                    self.write('dump_separate_members(api_dump);')
                 if validity_check is not None:
                     self.write(f'if({validity_check}) {{')
 
@@ -597,21 +592,21 @@ def generate_structs(self, structs, protect):
                 if validity_check is not None:
                     if not struct.union: # Union's use validity_check to only print the active element
                         self.write(f'''}} else {{
-                            if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {{
-                                dump_special<Format>("UNUSED", settings, "{custom_fullType}", "{member.name}", indents + 1);
-                            }} else if constexpr (Format == ApiDumpFormat::Json) {{
-                                dump_json_UNUSED(settings, "{custom_fullType}", "{member.name}", indents + 2);
+                            if (api_dump.settings().format() == ApiDumpFormat::Text || api_dump.settings().format() == ApiDumpFormat::Html) {{
+                                dump_special(api_dump, "UNUSED", "{custom_fullType}", "{member.name}", indents + 1);
+                            }} else if (api_dump.settings().format() == ApiDumpFormat::Json) {{
+                                dump_json_UNUSED(api_dump, "{custom_fullType}", "{member.name}", indents + 2);
                             }}''')
                     self.write('}')
 
             self.write('')
             for member in struct.members:
                 if member.pointer and member.name == 'pNext' and struct.name not in ['VkBaseInStructure', 'VkBaseOutStructure']:
-                    self.write('if constexpr (Format == ApiDumpFormat::Text) {')
-                    self.write(f'    dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "{member.fullType}", "{member.type}", indents < 2 ? indents + 1 : indents);')
+                    self.write('if (api_dump.settings().format() == ApiDumpFormat::Text) {')
+                    self.write(f'    dump_pNext_trampoline(api_dump, object.pNext, "{member.fullType}", "{member.type}", indents < 2 ? indents + 1 : indents);')
                     self.write('}')
 
-            self.write('dump_end<Format>(settings, OutputConstruct::api_struct, indents);')
+            self.write('dump_end(api_dump, OutputConstruct::api_struct, indents);')
             self.write('}')
         protect.add_guard(self, None)
 
@@ -629,9 +624,8 @@ def generate_implementation(self):
                 type_erase_handle = 'static_cast<void*>(object)'
             protect.add_guard(self, handle.protect)
             self.write(f'''
-                template <ApiDumpFormat Format>
-                void dump_{handle.name}(const {handle.name}& object, const ApiDumpSettings& settings, const char* type_name, const char *var_name, int indents, const void* address = nullptr) {{
-                    dump_handle<Format>({type_erase_handle}, settings, type_name, var_name, indents, address);
+                void dump_{handle.name}(ApiDumpInstance& api_dump, const {handle.name}& object, const char* type_name, const char *var_name, int indents, const void* address = nullptr) {{
+                    dump_handle(api_dump, {type_erase_handle}, type_name, var_name, indents, address);
                 }}''')
         protect.add_guard(self, None)
 
@@ -645,21 +639,20 @@ def generate_implementation(self):
         for bitmask in self.vk.bitmasks.values():
             protect.add_guard(self, bitmask.protect)
             self.write(f'''
-                template <ApiDumpFormat Format>
-                void dump_{bitmask.name}(const {bitmask.name} object, const ApiDumpSettings& settings, const char* 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;
+                void dump_{bitmask.name}(ApiDumpInstance& api_dump, const {bitmask.name} object, const char* type_name, const char *var_name, int indents, const void* address = nullptr) {{
+                    dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+                    dump_value_start(api_dump);
+                    api_dump.settings().stream() << object;
                     bool is_first = true;''')
             for field in bitmask.flags:
                 self.write(f'if(object {"==" if  field.zero or field.multiBit else "&"} {field.name}) {{')
-                self.write(f'settings.stream() << (is_first ? \" (\" : \" | \") << "{field.name}"; is_first = false;')
+                self.write(f'api_dump.settings().stream() << (is_first ? \" (\" : \" | \") << "{field.name}"; is_first = false;')
                 self.write('}')
             self.write('''
                 if(!is_first)
-                settings.stream() << ")";
-                dump_value_end<Format>(settings);
-                dump_end<Format>(settings, OutputConstruct::value, indents);
+                api_dump.settings().stream() << ")";
+                dump_value_end(api_dump);
+                dump_end(api_dump, OutputConstruct::value, indents);
                 }''')
         protect.add_guard(self, None)
 
@@ -667,25 +660,23 @@ def generate_implementation(self):
 
         for flag in self.vk.flags.values():
             protect.add_guard(self, flag.protect)
-            self.write('template <ApiDumpFormat Format>')
-            self.write(f'void dump_{flag.name}(const {flag.name} object, const ApiDumpSettings& settings, const char* type_name, const char *var_name, int indents, const void* address = nullptr) {{')
+            self.write(f'void dump_{flag.name}(ApiDumpInstance& api_dump, const {flag.name} object, const char* type_name, const char *var_name, int indents, const void* address = nullptr) {{')
             if flag.bitmaskName is not None:
-                self.write(f'dump_{flag.bitmaskName}<Format>(static_cast<{flag.bitmaskName}>(object), settings, type_name, var_name, indents, address);')
+                self.write(f'dump_{flag.bitmaskName}(api_dump, static_cast<{flag.bitmaskName}>(object), type_name, var_name, indents, address);')
             else:
-                self.write('dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);')
-                self.write('dump_value<Format>(settings, object);')
-                self.write('dump_end<Format>(settings, OutputConstruct::value, indents);')
+                self.write('dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);')
+                self.write('dump_value(api_dump, object);')
+                self.write('dump_end(api_dump, OutputConstruct::value, indents);')
             self.write('}')
         protect.add_guard(self, None)
 
         self.write('\n//======================= Func Pointer Implementations ======================//\n')
 
         for funcpointer in self.vk.funcPointers.values():
-            self.write('template <ApiDumpFormat Format>')
-            self.write(f'''void dump_{funcpointer.name}(const {funcpointer.name} object, const ApiDumpSettings& settings, const char* 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);
+            self.write(f'''void dump_{funcpointer.name}(ApiDumpInstance& api_dump, const {funcpointer.name} object, const char* type_name, const char *var_name, int indents, const void* address = nullptr) {{
+                dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents, address);
+                dump_address(api_dump, &object);
+                dump_end(api_dump, OutputConstruct::value, indents);
             }}''')
 
         self.write('\n//=================== Video Struct and Union Implementations ==================//\n')
@@ -696,45 +687,43 @@ def generate_implementation(self):
 
         self.write('\n//======================== pNext Chain Implementation =======================//\n')
         self.write('''
-            template <ApiDumpFormat Format>
-            void dump_pNext_struct_name(const void* object, const ApiDumpSettings& settings, const char* type_name, const char *var_name, int indents) {
+            void dump_pNext_struct_name(ApiDumpInstance& api_dump, const void* object, const char* type_name, const char *var_name, int indents) {
                 if (object == nullptr) {
-                    dump_nullptr<Format>(settings, type_name, var_name, indents);
+                    dump_nullptr(api_dump, 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);
+                        dump_pNext_struct_name(api_dump, base_struct.pNext, type_name, var_name, indents);
                     } else {
-                        dump_nullptr<Format>(settings, "const void*", "pNext", indents);
+                        dump_nullptr(api_dump, "const void*", "pNext", indents);
                     }
                     return;
                 }
-                dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents);
+                dump_start(api_dump, OutputConstruct::value, type_name, var_name, indents);
                 switch(base_struct.sType) {''')
         for struct in [ x for x in self.vk.structs.values() if not x.union ]:
             protect.add_guard(self, struct.protect)
             if struct.sType is not None:
                 self.write(f'''
                     case {struct.sType}:
-                        dump_string<Format>(settings, "{struct.name}");
+                        dump_value(api_dump, "{struct.name}");
                         break;''')
         protect.add_guard(self, None)
         self.write('''
                 default:
-                    dump_string<Format>(settings, "NULL");
+                    dump_value(api_dump, "NULL");
                     break;
                 }
-                dump_end<Format>(settings, OutputConstruct::value, indents);
+                dump_end(api_dump, 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) {
+            void dump_pNext_trampoline(ApiDumpInstance& api_dump, const void* object, 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);
+                    if (api_dump.settings().format() == ApiDumpFormat::Html || api_dump.settings().format() == ApiDumpFormat::Json) {
+                        dump_nullptr(api_dump, type_name, var_name, indents);
                     }
                     return;
                 }
@@ -746,22 +735,22 @@ def generate_implementation(self):
             if struct.sType is not None:
                 self.write(f'''
                     case {struct.sType}:
-                        dump_{struct.name}<Format>(*reinterpret_cast<const {struct.name}*>(object), settings, (Format == ApiDumpFormat::Json ? "{struct.name}*" : "{struct.name}"), "pNext", indents, reinterpret_cast<const {struct.name}*>(object));
+                        dump_{struct.name}(api_dump, *reinterpret_cast<const {struct.name}*>(object), (api_dump.settings().format() == ApiDumpFormat::Json ? "{struct.name}*" : "{struct.name}"), "pNext", indents, reinterpret_cast<const {struct.name}*>(object));
                         break;''')
         protect.add_guard(self, None)
         self.write('''
                 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);
+                        dump_pNext_trampoline(api_dump, reinterpret_cast<const void*>(base_struct.pNext), type_name, var_name, indents);
                     } else {
-                        dump_nullptr<Format>(settings, "const void*", "pNext", indents);
+                        dump_nullptr(api_dump, "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);
+                    dump_start(api_dump, OutputConstruct::value, "const void*", "pNext", indents);
+                    dump_value(api_dump, "UNKNOWN (", (int64_t) (base_struct.sType), ")");
+                    dump_end(api_dump, OutputConstruct::value, indents);
                     }
                 }''')
 
@@ -770,14 +759,12 @@ def generate_implementation(self):
         for command in [x for x in self.vk.commands.values() if x.name not in FUNCTION_IMPLEMENTATION_IGNORE_LIST]:
             protect.add_guard(self, command.protect)
             self.write(f'''
-                template <ApiDumpFormat Format>
-                void dump_params_{command.name}(ApiDumpInstance& dump_inst, {command_param_declaration_text(command)}) {{
-                    const ApiDumpSettings& settings(dump_inst.settings());
-                    if(settings.showParams()) {{
-                        dump_pre_params_formatting<Format>(settings);''')
+                void dump_params_{command.name}(ApiDumpInstance& api_dump, {command_param_declaration_text(command)}) {{
+                    if(api_dump.settings().showParams()) {{
+                        dump_pre_params_formatting(api_dump);''')
             for param in command.params:
                 if param != command.params[0]:
-                    self.write('dump_separate_members<Format>(settings);')
+                    self.write('dump_separate_members(api_dump);')
 
                 parameter_state = self.get_parameter_state(param, command)
                 if parameter_state is not None:
@@ -785,17 +772,16 @@ def generate_implementation(self):
 
                 self.write_value(param, command)
 
-            self.write('''dump_post_params_formatting<Format>(settings);
-                    flush(settings);
+            self.write('''dump_post_params_formatting(api_dump);
+                    api_dump.settings().flush();
                 }
             }''')
         protect.add_guard(self, None)
 
         self.write('\n//========================== Type Implementations =========================//\n')
         self.write('''
-            template <ApiDumpFormat Format>
-            void dump_return_value_VkDeviceAddress(const VkDeviceAddress& address, const ApiDumpSettings& settings) {
-                dump_value_hex<Format>(settings, static_cast<uint64_t>(address));
+            void dump_return_value_VkDeviceAddress(ApiDumpInstance& api_dump, const VkDeviceAddress& address) {
+                dump_value_hex(api_dump, static_cast<uint64_t>(address));
             }''')
 
     def build_alias_map(self):
@@ -910,73 +896,73 @@ def write_value(self, var, parent):
         object_access = 'object.' if isinstance(parent, Struct) else ''
         call_type = self.get_unaliased_type(var.type)
         if isinstance(parent, Command):
-            indent = '(Format == ApiDumpFormat::Json ? 4 : 1)'
+            indent = '(api_dump.settings().format() == ApiDumpFormat::Json ? 4 : 1)'
         else:
-            indent = 'indents + (Format == ApiDumpFormat::Json ? 2 : 1)'
+            indent = 'indents + (api_dump.settings().format() == ApiDumpFormat::Json ? 2 : 1)'
 
         value = f'{object_access}{var.name}'
         if self.get_is_array(var):
-            element_type = f'dump_type<Format, {custom_type}>'
+            element_type = f'dump_type<{custom_type}>'
             if var.type == 'char':
-                element_type = 'dump_char<Format>'
+                element_type = 'dump_char'
             if custom_type == 'uint8_t': # ostream << treats uint8_t as char which we dont want
-                element_type = 'dump_type<Format, uint32_t>'
+                element_type = 'dump_type<uint32_t>'
             elif custom_type == 'int8_t': # ostream << treats int8_t as char which we dont want
-                element_type = 'dump_type<Format, int32_t>'
+                element_type = 'dump_type<int32_t>'
 
             elif call_type in self.vulkan_defined_types:
-                element_type = f'dump_{call_type}<Format>'
+                element_type = f'dump_{call_type}'
 
             if parent.name in ['VkShaderModuleCreateInfo', 'VkShaderCreateInfoEXT'] and var.name == 'pCode':
                 array_len = f'{object_access}{var.length}'
                 self.write(f'''
-                    if(settings.showShader()) {{
-                        dump_spirv<Format>({value}, {array_len}, settings, "{custom_fullType}", "{var.name}", {indent});
+                    if(api_dump.settings().showShader()) {{
+                        dump_spirv(api_dump, {value}, {array_len}, "{custom_fullType}", "{var.name}", {indent});
                     }} else {{
-                        dump_special<Format>("SHADER DATA", settings, "{var.fullType}", "{var.name}", {indent});
+                        dump_special(api_dump, "SHADER DATA", "{var.fullType}", "{var.name}", {indent});
                     }}''')
 
             elif len(var.fixedSizeArray) > 2:
                 raise RuntimeError("Unhandled fixed array dimentionality")
             elif len(var.fixedSizeArray) == 2:
-                self.write(f'dump_double_array<Format>({value}, {var.fixedSizeArray[0]},  {var.fixedSizeArray[1]}, settings, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
+                self.write(f'dump_double_array(api_dump, {value}, {var.fixedSizeArray[0]},  {var.fixedSizeArray[1]}, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
 
             elif len(var.fixedSizeArray) == 1 and isinstance(parent, Struct): # Fixed length array's passed as parameters are treated as void*, so only match when printing members
                 fixed_array_len = get_fixed_array_length(var.fixedSizeArray[0], var, parent)
-                self.write(f'dump_single_array<Format>({value}, {fixed_array_len}, settings, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
+                self.write(f'dump_single_array(api_dump, {value}, {fixed_array_len}, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
 
             else:
                 array_len = get_array_length(var, parent)
                 if var.fullType.count('*') > 1 and var.type not in ['void', 'char'] and (call_type in self.vulkan_defined_types):
-                    self.write(f'dump_double_pointer_array<Format>({value}, {array_len}, settings, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
+                    self.write(f'dump_double_pointer_array(api_dump, {value}, {array_len}, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
                 else:
-                    self.write(f'dump_pointer_array<Format>({value}, {array_len}, settings, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
+                    self.write(f'dump_pointer_array(api_dump, {value}, {array_len}, "{custom_fullType}", "{var.name}", "{custom_type}", {indent}, {element_type});')
         else:
             if var.pointer and var.type not in self.only_use_as_pointer_types and var.type not in self.vk.funcPointers.keys() and var.type not in ['void', 'char'] and not (var.name == 'pNext' and var.fullType in ['void*', 'const void*']):
-                pointer_type = f'dump_type<Format, {custom_type}>'
+                pointer_type = f'dump_type<{custom_type}>'
                 if (var.type in self.vulkan_defined_types):
-                    pointer_type = f'dump_{call_type}<Format>'
+                    pointer_type = f'dump_{call_type}'
 
-                self.write(f'dump_pointer<Format>({value}, settings, "{custom_fullType}", "{var.name}", {indent}, {pointer_type});')
+                self.write(f'dump_pointer(api_dump, {value}, "{custom_fullType}", "{var.name}", {indent}, {pointer_type});')
             else:
-                value_type = f'dump_type<Format, {var.fullType}>'
+                value_type = f'dump_type<{var.fullType}>'
                 if var.name == 'apiVersion':
-                    value_type = 'dump_api_version<Format>'
+                    value_type = 'dump_api_version'
                 elif var.name == 'pNext' and var.fullType in ['void*', 'const void*']:
-                    value_type = 'dump_pNext<Format>'
+                    value_type = 'dump_pNext'
                 elif var.type == 'char':
-                    value_type = 'dump_char<Format>'
+                    value_type = 'dump_char'
                 elif var.fullType == 'VkDeviceAddress':
-                    value_type = f'dump_type_hex<Format, {var.fullType}>'
+                    value_type = f'dump_type_hex< {var.fullType}>'
                 elif var.fullType == 'uint8_t': # ostream << treats uint8_t as char which we dont want
-                    value_type = 'dump_type<Format, uint32_t>'
+                    value_type = 'dump_type< uint32_t>'
                 elif var.fullType == 'int8_t': # ostream << treats int8_t as char which we dont want
-                    value_type = 'dump_type<Format, int32_t>'
+                    value_type = 'dump_type< int32_t>'
                 elif call_type in self.vulkan_defined_types:
-                    value_type = f'dump_{call_type}<Format>'
+                    value_type = f'dump_{call_type}'
                 elif var.type in TREAT_AS_POINTERS and TREAT_AS_POINTERS[var.type] == var.name:
-                    value_type = 'dump_uint64_t_as_pointer<Format>'
-                self.write(f'{value_type}({value}, settings, "{custom_fullType}", "{var.name}", {indent});')
+                    value_type = 'dump_uint64_t_as_pointer'
+                self.write(f'{value_type}(api_dump, {value}, "{custom_fullType}", "{var.name}", {indent});')
 
     def write_enum_contents(self, enum):
         int_cast = ('' if any(f.negative for f in enum.fields) else 'u') + (f'int{enum.bitWidth}_t')
@@ -987,9 +973,9 @@ def write_enum_contents(self, enum):
         for field in enum.fields:
             protect.add_guard(self, field.protect)
             self.write(f'''case {field.name}:
-                    dump_enum<Format>(settings, "{field.name}", static_cast<{int_cast}>(object));
+                    dump_enum(api_dump, "{field.name}", static_cast<{int_cast}>(object));
                     break;''')
         protect.add_guard(self, None)
         self.write('default:')
-        self.write(f'    dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<{int_cast}>(object));')
+        self.write(f'    dump_enum_with_value(api_dump, "UNKNOWN", static_cast<{int_cast}>(object));')
         self.write('}')