[Rust] [Axum] Deduplicate code from rust-axum generator (#17588)

* [Rust] [Axum] Deduplicate code from rust-axum generator

* Fix build

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustAxumServerCodegen.java

@@ -11,7 +11,6 @@ import io.swagger.v3.oas.models.parameters.Parameter;
 import io.swagger.v3.oas.models.parameters.RequestBody;
 import io.swagger.v3.oas.models.responses.ApiResponse;
 import io.swagger.v3.oas.models.servers.Server;
-import joptsimple.internal.Strings;
 import org.apache.commons.io.FilenameUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.openapitools.codegen.*;
@@ -26,14 +25,13 @@ import org.openapitools.codegen.model.ModelsMap;
 import org.openapitools.codegen.model.OperationMap;
 import org.openapitools.codegen.model.OperationsMap;
 import org.openapitools.codegen.utils.ModelUtils;
-import org.openapitools.codegen.utils.URLPathUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.io.IOException;
 import java.math.BigInteger;
-import java.net.URL;
+import java.nio.file.Path;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -42,17 +40,31 @@ import static org.openapitools.codegen.utils.StringUtils.underscore;
 
 public class RustAxumServerCodegen extends AbstractRustCodegen implements CodegenConfig {
     public static final String PROJECT_NAME = "openapi-server";
+    private static final String apiPath = "rust-axum";
+
+    private String packageName;
+    private String packageVersion;
+    private Boolean disableValidator = false;
+    private Boolean allowBlockingValidator = false;
+    private Boolean allowBlockingResponseSerialize = false;
+    private String externCrateName;
+
     // Types
     private static final String uuidType = "uuid::Uuid";
     private static final String bytesType = "ByteArray";
+    private static final String dateType = "chrono::naive::NaiveDate";
+    private static final String dateTimeType = "chrono::DateTime::<chrono::Utc>";
+    private static final String stringType = "String";
+    private static final String objectType = "crate::types::Object";
+    private static final String mapType = "std::collections::HashMap";
+    private static final String vecType = "Vec";
+
+    // Mime
     private static final String octetMimeType = "application/octet-stream";
     private static final String plainTextMimeType = "text/plain";
-
     private static final String xmlMimeType = "application/xml";
     private static final String textXmlMimeType = "text/xml";
-
     private static final String formUrlEncodedMimeType = "application/x-www-form-urlencoded";
-
     private static final String jsonMimeType = "application/json";
     // RFC 7386 support
     private static final String mergePatchJsonMimeType = "application/merge-patch+json";
@@ -60,19 +72,11 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
     private static final String problemJsonMimeType = "application/problem+json";
     private static final String problemXmlMimeType = "application/problem+xml";
 
-    private final Logger LOGGER = LoggerFactory.getLogger(RustAxumServerCodegen.class);
     // Grouping (Method, Operation) by Path.
     private final Map<String, ArrayList<MethodOperation>> pathMethodOpMap = new HashMap<>();
 
-    protected String apiVersion = "1.0.0";
+    // Logger
-    protected String apiPath = "rust-axum";
+    private final Logger LOGGER = LoggerFactory.getLogger(RustAxumServerCodegen.class);
-    protected String packageName;
-    protected String packageVersion;
-    protected Boolean disableValidator = false;
-    protected Boolean allowBlockingValidator = false;
-    protected Boolean allowBlockingResponseSerialize = false;
-    protected String externCrateName;
-    protected int serverPort = 8080;
 
     public RustAxumServerCodegen() {
         super();
@@ -109,7 +113,7 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
         hideGenerationTimestamp = Boolean.FALSE;
 
         // set the output folder here
-        outputFolder = "generated-code" + File.separator + "rust-axum";
+        outputFolder = Path.of("generated-code", "rust-axum").toString();
         embeddedTemplateDir = templateDir = "rust-axum";
 
         importMapping = new HashMap<>();
@@ -118,13 +122,11 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
 
         // types
         defaultIncludes = new HashSet<>(
-                Arrays.asList(
+                Set.of("map", "array")
-                        "map",
-                        "array")
         );
 
         languageSpecificPrimitives = new HashSet<>(
-                Arrays.asList(
+                Set.of(
                         "bool",
                         "char",
                         "i8",
@@ -140,49 +142,48 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
                         "f32",
                         "f64",
                         "str",
-                        "String")
+                        stringType)
         );
+        assert languageSpecificPrimitives.size() == 16;
 
-        instantiationTypes.clear();
+        instantiationTypes = new HashMap<>(
-        instantiationTypes.put("array", "Vec");
+                Map.of(
-        instantiationTypes.put("map", "std::collections::HashMap");
+                        "array", vecType,
+                        "map", mapType
+                )
+        );
+        assert instantiationTypes.size() == 2;
 
-        typeMapping.clear();
+        typeMapping = new HashMap<>(Map.ofEntries(
-        typeMapping.put("number", "f64");
+                new AbstractMap.SimpleEntry<>("number", "f64"),
-        typeMapping.put("integer", "i32");
+                new AbstractMap.SimpleEntry<>("integer", "i32"),
-        typeMapping.put("long", "i64");
+                new AbstractMap.SimpleEntry<>("long", "i64"),
-        typeMapping.put("float", "f32");
+                new AbstractMap.SimpleEntry<>("float", "f32"),
-        typeMapping.put("double", "f64");
+                new AbstractMap.SimpleEntry<>("double", "f64"),
-        typeMapping.put("string", "String");
+                new AbstractMap.SimpleEntry<>("string", stringType),
-        typeMapping.put("UUID", uuidType);
+                new AbstractMap.SimpleEntry<>("UUID", uuidType),
-        typeMapping.put("URI", "String");
+                new AbstractMap.SimpleEntry<>("URI", stringType),
-        typeMapping.put("byte", "u8");
+                new AbstractMap.SimpleEntry<>("byte", "u8"),
-        typeMapping.put("ByteArray", bytesType);
+                new AbstractMap.SimpleEntry<>("ByteArray", bytesType),
-        typeMapping.put("binary", bytesType);
+                new AbstractMap.SimpleEntry<>("binary", bytesType),
-        typeMapping.put("boolean", "bool");
+                new AbstractMap.SimpleEntry<>("boolean", "bool"),
-        typeMapping.put("date", "chrono::naive::NaiveDate");
+                new AbstractMap.SimpleEntry<>("date", dateType),
-        typeMapping.put("DateTime", "chrono::DateTime::<chrono::Utc>");
+                new AbstractMap.SimpleEntry<>("DateTime", dateTimeType),
-        typeMapping.put("password", "String");
+                new AbstractMap.SimpleEntry<>("password", stringType),
-        typeMapping.put("File", "ByteArray");
+                new AbstractMap.SimpleEntry<>("File", bytesType),
-        typeMapping.put("file", "ByteArray");
+                new AbstractMap.SimpleEntry<>("file", bytesType),
-        typeMapping.put("array", "Vec");
+                new AbstractMap.SimpleEntry<>("array", vecType),
-        typeMapping.put("map", "std::collections::HashMap");
+                new AbstractMap.SimpleEntry<>("map", mapType),
-        typeMapping.put("object", "crate::types::Object");
+                new AbstractMap.SimpleEntry<>("object", objectType),
-        typeMapping.put("AnyType", "crate::types::Object");
+                new AbstractMap.SimpleEntry<>("AnyType", objectType)
+        ));
+        assert typeMapping.size() == 21;
 
         // cli options
-        cliOptions.clear();
-        cliOptions.add(new CliOption(CodegenConstants.PACKAGE_NAME,
-                "Rust crate name (convention: snake_case).")
-                .defaultValue("openapi"));
-        cliOptions.add(new CliOption(CodegenConstants.PACKAGE_VERSION,
-                "Rust crate version."));
-
         CliOption optDisableValidator = new CliOption("disableValidator", "Disable validating request-data (header, path, query, body) " +
                 "against OpenAPI Schema Specification.");
         optDisableValidator.setType("bool");
         optDisableValidator.defaultValue(disableValidator.toString());
-        cliOptions.add(optDisableValidator);
 
         CliOption optAllowBlockingValidator = new CliOption("allowBlockingValidator",
                 String.join("",
@@ -193,7 +194,6 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
                         "is low cost."));
         optAllowBlockingValidator.setType("bool");
         optAllowBlockingValidator.defaultValue(allowBlockingValidator.toString());
-        cliOptions.add(optAllowBlockingValidator);
 
         CliOption optAllowBlockingResponseSerialize = new CliOption("allowBlockingResponseSerialize",
                 String.join("", "By default, json/form-urlencoded response serialization, which might ",
@@ -203,10 +203,19 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
                         "serialization (e.g. returns tiny data) is low cost."));
         optAllowBlockingResponseSerialize.setType("bool");
         optAllowBlockingResponseSerialize.defaultValue(allowBlockingResponseSerialize.toString());
-        cliOptions.add(optAllowBlockingResponseSerialize);
 
-        additionalProperties.put("apiVersion", apiVersion);
+        cliOptions = new ArrayList<>(
-        additionalProperties.put("apiPath", apiPath);
+                List.of(
+                        new CliOption(CodegenConstants.PACKAGE_NAME,
+                                "Rust crate name (convention: snake_case).")
+                                .defaultValue("openapi"),
+                        new CliOption(CodegenConstants.PACKAGE_VERSION,
+                                "Rust crate version."),
+                        optDisableValidator,
+                        optAllowBlockingValidator,
+                        optAllowBlockingResponseSerialize
+                )
+        );
 
         supportingFiles.add(new SupportingFile("Cargo.mustache", "", "Cargo.toml"));
         supportingFiles.add(new SupportingFile("gitignore", "", ".gitignore"));
@@ -276,7 +285,7 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
         }
 
         if (additionalProperties.containsKey("allowBlockingResponseSerialize")) {
-            allowBlockingValidator = convertPropertyToBooleanAndWriteBack("allowBlockingResponseSerialize");
+            allowBlockingResponseSerialize = convertPropertyToBooleanAndWriteBack("allowBlockingResponseSerialize");
         } else {
             additionalProperties.put("allowBlockingResponseSerialize", allowBlockingResponseSerialize);
         }
@@ -302,10 +311,6 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
     public void preprocessOpenAPI(OpenAPI openAPI) {
         Info info = openAPI.getInfo();
 
-        URL url = URLPathUtils.getServerURL(openAPI, serverVariableOverrides());
-        additionalProperties.put("serverHost", url.getHost());
-        additionalProperties.put("serverPort", URLPathUtils.getPort(url, serverPort));
-
         if (packageVersion == null || packageVersion.isEmpty()) {
             List<String> versionComponents = new ArrayList<>(Arrays.asList(info.getVersion().split("[.]")));
             if (versionComponents.isEmpty()) {
@@ -323,10 +328,9 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
 
     @Override
     public String toApiName(String name) {
-        if (name.isEmpty()) {
+        return name.isEmpty() ?
-            return "default";
+                "default" :
-        }
+                sanitizeIdentifier(name, CasingType.SNAKE_CASE, "api", "API", true);
-        return sanitizeIdentifier(name, CasingType.SNAKE_CASE, "api", "API", true);
     }
 
     /**
@@ -335,7 +339,7 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
      */
     @Override
     public String apiFileFolder() {
-        return outputFolder + File.separator + apiPackage().replace('.', File.separatorChar);
+        return Path.of(outputFolder, apiPackage().replace('.', File.separatorChar)).toString();
     }
 
     @Override
@@ -348,6 +352,10 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
         return "\"" + super.toEnumValue(value, datatype) + "\"";
     }
 
+    private boolean isObjectType(String type) {
+        return "object".equals(type);
+    }
+
     private boolean isMimetypeXml(String mimetype) {
         return mimetype.toLowerCase(Locale.ROOT).startsWith(xmlMimeType) ||
                 mimetype.toLowerCase(Locale.ROOT).startsWith(problemXmlMimeType) ||
@@ -483,11 +491,6 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
                         outputMime = jsonMimeType;
                     }
                 } else {
-                    // If we know exactly what mimetype this response is
-                    // going to produce, then use that. If we have not found
-                    // anything, then we'll fall back to the 'producesXXX'
-                    // definitions we worked out above for the operation as a
-                    // whole.
                     if (isMimetypeWwwFormUrlEncoded(firstProduces)) {
                         producesFormUrlEncoded = true;
                         producesPlainText = false;
@@ -509,8 +512,6 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
 
                 rsp.vendorExtensions.put("x-mime-type", outputMime);
 
-                // Write out the type of data we actually expect this response
-                // to make.
                 if (producesFormUrlEncoded) {
                     rsp.vendorExtensions.put("x-produces-form-urlencoded", true);
                 } else if (producesPlainText) {
@@ -529,11 +530,8 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
                     }
                 } else {
                     rsp.vendorExtensions.put("x-produces-json", true);
-                    // If the data type is just "object", then ensure that the
+                    if (isObjectType(rsp.dataType)) {
-                    // Rust data type is "crate::types::Object".  This allows us
+                        rsp.dataType = objectType;
-                    // to define APIs that can return arbitrary JSON bodies.
-                    if ("object".equals(rsp.dataType)) {
-                        rsp.dataType = "crate::types::Object";
                     }
                 }
             }
@@ -557,15 +555,15 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
     }
 
     @Override
-    public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels) {
+    public OperationsMap postProcessOperationsWithModels(OperationsMap operationsMap, List<ModelMap> allModels) {
-        OperationMap operations = objs.getOperations();
+        OperationMap operations = operationsMap.getOperations();
         List<CodegenOperation> operationList = operations.getOperation();
 
         for (CodegenOperation op : operationList) {
             postProcessOperationWithModels(op);
         }
 
-        return objs;
+        return operationsMap;
     }
 
     private void postProcessOperationWithModels(CodegenOperation op) {
@@ -793,7 +791,8 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
         String defaultValue = null;
         if ((ModelUtils.isNullable(p)) && (p.getDefault() != null) && ("null".equalsIgnoreCase(p.getDefault().toString())))
             return "Nullable::Null";
-        else if (ModelUtils.isBooleanSchema(p)) {
+
+        if (ModelUtils.isBooleanSchema(p)) {
             if (p.getDefault() != null) {
                 if ("false".equalsIgnoreCase(p.getDefault().toString()))
                     defaultValue = "false";
@@ -813,18 +812,20 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
                 defaultValue = "\"" + p.getDefault() + "\".to_string()";
             }
         }
+
         if ((defaultValue != null) && (ModelUtils.isNullable(p)))
             defaultValue = "Nullable::Present(" + defaultValue + ")";
+
         return defaultValue;
     }
 
     @Override
     public void postProcessModelProperty(CodegenModel model, CodegenProperty property) {
         super.postProcessModelProperty(model, property);
+
         if (!languageSpecificPrimitives.contains(property.dataType)) {
-            // If we use a more qualified model name, then only camelize the actual type, not the qualifier.
+            final int position = property.dataType.lastIndexOf(":");
-            if (property.dataType.contains(":")) {
+            if (position != -1) {
-                int position = property.dataType.lastIndexOf(":");
                 property.dataType = property.dataType.substring(0, position) + camelize(property.dataType.substring(position));
             } else {
                 property.dataType = camelize(property.dataType);
@@ -836,42 +837,12 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
 
         // Integer type fitting
         if (Objects.equals(property.baseType, "integer")) {
-
             BigInteger minimum = Optional.ofNullable(property.getMinimum()).map(BigInteger::new).orElse(null);
             BigInteger maximum = Optional.ofNullable(property.getMaximum()).map(BigInteger::new).orElse(null);
-
+            property.dataType = bestFittingIntegerType(
-            boolean unsigned = canFitIntoUnsigned(minimum, property.getExclusiveMinimum());
+                    minimum, property.getExclusiveMinimum(),
-
+                    maximum, property.getExclusiveMaximum(),
-            if (Strings.isNullOrEmpty(property.dataFormat)) {
+                    true);
-                property.dataType = bestFittingIntegerType(minimum,
-                        property.getExclusiveMinimum(),
-                        maximum,
-                        property.getExclusiveMaximum(),
-                        true);
-            } else {
-                switch (property.dataFormat) {
-                    // custom integer formats (legacy)
-                    case "uint32":
-                        property.dataType = "u32";
-                        break;
-                    case "uint64":
-                        property.dataType = "u64";
-                        break;
-                    case "int32":
-                        property.dataType = unsigned ? "u32" : "i32";
-                        break;
-                    case "int64":
-                        property.dataType = unsigned ? "u64" : "i64";
-                        break;
-                    default:
-                        LOGGER.warn("The integer format '{}' is not recognized and will be ignored.", property.dataFormat);
-                        property.dataType = bestFittingIntegerType(minimum,
-                                property.getExclusiveMinimum(),
-                                maximum,
-                                property.getExclusiveMaximum(),
-                                true);
-                }
-            }
         }
 
         property.name = underscore(property.name);
@@ -880,57 +851,41 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
             property.defaultValue = (property.defaultValue != null) ? "Some(" + property.defaultValue + ")" : "None";
         }
 
-        // If a property has no type defined in the schema, it can take values of any type.
+        if (isObjectType(property.baseType)) {
-        // This clashes with Rust being statically typed. Hence, assume it's sent as a json
+            property.dataType = objectType;
-        // blob and return the json value to the user of the API and let the user determine
-        // the type from the value. If the property has no type, at this point it will have
-        // baseType "object" allowing us to identify such properties. Moreover, set to not
-        // nullable, we can use the crate::types::Object::Null enum variant.
-        if ("object".equals(property.baseType)) {
-            property.dataType = "crate::types::Object";
             property.isNullable = false;
         }
     }
 
     @Override
-    public ModelsMap postProcessModels(ModelsMap objs) {
+    public ModelsMap postProcessModels(ModelsMap modelsMap) {
-        for (ModelMap mo : objs.getModels()) {
+        for (ModelMap mo : modelsMap.getModels()) {
             CodegenModel cm = mo.getModel();
 
             LOGGER.trace("Post processing model: {}", cm);
 
-            if ("object".equals(cm.dataType)) {
+            if (isObjectType(cm.dataType)) {
                 // Object isn't a sensible default. Instead, we set it to
                 // 'null'. This ensures that we treat this model as a struct
                 // with multiple parameters.
                 cm.dataType = null;
             } else if ("map".equals(cm.dataType)) {
                 if (!cm.allVars.isEmpty() || cm.additionalPropertiesType == null) {
-                    // We don't yet support `additionalProperties` that also have
-                    // properties. If we see variables, we ignore the
-                    // `additionalProperties` type ('map') and warn the user. This
-                    // will produce code that compiles, but won't feature the
-                    // `additionalProperties` - but that's likely more useful to
-                    // the user than the alternative.
                     LOGGER.warn("Ignoring additionalProperties (see https://github.com/OpenAPITools/openapi-generator/issues/318) alongside defined properties");
                     cm.dataType = null;
                 } else {
-                    cm.dataType = "std::collections::HashMap<String, " + cm.additionalPropertiesType + ">";
+                    cm.dataType = mapType + "<String, " + cm.additionalPropertiesType + ">";
                 }
             } else if (cm.dataType != null) {
                 // We need to hack about with single-parameter models to
                 // get them recognised correctly.
                 cm.isAlias = false;
                 cm.dataType = typeMapping.get(cm.dataType);
-
-                if (uuidType.equals(cm.dataType)) {
-                    additionalProperties.put("apiUsesUuid", true);
-                }
             }
 
-            cm.vendorExtensions.put("x-is-string", "String".equals(cm.dataType));
+            cm.vendorExtensions.put("x-is-string", stringType.equals(cm.dataType));
         }
-        return super.postProcessModelsEnum(objs);
+        return super.postProcessModelsEnum(modelsMap);
     }
 
     @Override
@@ -939,24 +894,30 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
             return;
         }
 
-        String commandPrefix = System.getenv("RUST_POST_PROCESS_FILE");
+        final String fileName = file.toString();
-        if (StringUtils.isEmpty(commandPrefix)) {
+
-            commandPrefix = "rustfmt";
+        String[] command;
+
+        String cmd = System.getenv("RUST_POST_PROCESS_FILE");
+        if (StringUtils.isEmpty(cmd)) {
+            cmd = "rustfmt";
+            command = new String[]{cmd, "--edition", "2021", fileName};
+        } else {
+            command = new String[]{cmd, fileName};
         }
 
         // only process files with .rs extension
-        if ("rs".equals(FilenameUtils.getExtension(file.toString()))) {
+        if ("rs".equals(FilenameUtils.getExtension(fileName))) {
             try {
-                Process p = Runtime.getRuntime().exec(new String[]{commandPrefix, "--edition", "2021", file.toString()});
+                Process p = Runtime.getRuntime().exec(command);
                 int exitValue = p.waitFor();
                 if (exitValue != 0) {
-                    LOGGER.error("Error running the command ({} {}). Exit code: {}", commandPrefix, file, exitValue);
+                    LOGGER.error("Error running the command ({} {}). Exit code: {}", cmd, file, exitValue);
                 } else {
-                    LOGGER.info("Successfully executed: {} {}", commandPrefix, file);
+                    LOGGER.info("Successfully executed: {} {}", cmd, file);
                 }
             } catch (InterruptedException | IOException e) {
-                LOGGER.error("Error running the command ({} {}). Exception: {}", commandPrefix, file, e.getMessage());
+                LOGGER.error("Error running the command ({} {}). Exception: {}", cmd, file, e.getMessage());
-                // Restore interrupted state
                 Thread.currentThread().interrupt();
             }
         }
@@ -964,9 +925,6 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
 
     @Override
     protected void updateParameterForString(CodegenParameter codegenParameter, Schema parameterSchema) {
-        /*
-          we have a custom version of this function to set isString to false for uuid
-         */
         if (ModelUtils.isEmailSchema(parameterSchema)) {
             codegenParameter.isEmail = true;
         } else if (ModelUtils.isUUIDSchema(parameterSchema)) {
@@ -1000,9 +958,6 @@ public class RustAxumServerCodegen extends AbstractRustCodegen implements Codege
 
     @Override
     protected void updatePropertyForAnyType(CodegenProperty property, Schema p) {
-        /*
-         * we have a custom version of this function to not set isNullable to true
-         */
         // The 'null' value is allowed when the OAS schema is 'any type'.
         // See https://github.com/OAI/OpenAPI-Specification/issues/1389
         if (Boolean.FALSE.equals(p.getNullable())) {

samples/server/petstore/rust-axum/output/multipart-v3/src/header.rs

@@ -30,11 +30,16 @@ macro_rules! ihv_generate {
                 match hdr_value.to_str() {
                     Ok(hdr_value) => match hdr_value.parse::<$t>() {
                         Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!("Unable to parse {} as a string: {}",
+                        Err(e) => Err(format!(
-                            stringify!($t), e)),
+                            "Unable to parse {} as a string: {}",
+                            stringify!($t),
+                            e
+                        )),
                     },
-                    Err(e) => Err(format!("Unable to parse header {:?} as a string - {}",
+                    Err(e) => Err(format!(
-                        hdr_value, e)),
+                        "Unable to parse header {:?} as a string - {}",
+                        hdr_value, e
+                    )),
                 }
             }
         }
@@ -69,14 +74,17 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(
                 hdr_value
-                .split(',')
+                    .split(',')
-                .filter_map(|x| match x.trim() {
+                    .filter_map(|x| match x.trim() {
-                    "" => None,
+                        "" => None,
-                    y => Some(y.to_string()),
+                        y => Some(y.to_string()),
-                })
+                    })
-                .collect())),
+                    .collect(),
-            Err(e) => Err(format!("Unable to parse header: {:?} as a string - {}",
+            )),
-                hdr_value, e)),
+            Err(e) => Err(format!(
+                "Unable to parse header: {:?} as a string - {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -85,11 +93,13 @@ impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
     type Error = String;
 
     fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-       match HeaderValue::from_str(&hdr_value.0.join(", ")) {
+        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-           Ok(hdr_value) => Ok(hdr_value),
+            Ok(hdr_value) => Ok(hdr_value),
-           Err(e) => Err(format!("Unable to convert {:?} into a header - {}",
+            Err(e) => Err(format!(
-               hdr_value, e))
+                "Unable to convert {:?} into a header - {}",
-       }
+                hdr_value, e
+            )),
+        }
     }
 }
 
@@ -101,8 +111,7 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
     fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}",
+            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-                hdr_value, e)),
         }
     }
 }
@@ -113,8 +122,10 @@ impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -128,11 +139,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match hdr_value.parse() {
                 Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}",
+                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -143,8 +155,10 @@ impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0.to_string()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert: {:?} into a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert: {:?} into a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -158,11 +172,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
                 Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}",
+                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert header {:?} to string {}",
+            Err(e) => Err(format!(
-                    hdr_value, e)),
+                "Unable to convert header {:?} to string {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -173,8 +188,10 @@ impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} to a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} to a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }

samples/server/petstore/rust-axum/output/multipart-v3/src/lib.rs

@@ -1,4 +1,12 @@
-#![allow(missing_docs, trivial_casts, unused_variables, unused_mut, unused_imports, unused_extern_crates, non_camel_case_types)]
+#![allow(
+    missing_docs,
+    trivial_casts,
+    unused_variables,
+    unused_mut,
+    unused_imports,
+    unused_extern_crates,
+    non_camel_case_types
+)]
 #![allow(unused_imports, unused_attributes)]
 #![allow(clippy::derive_partial_eq_without_eq, clippy::disallowed_names)]
 
@@ -14,65 +22,60 @@ use types::*;
 pub const BASE_PATH: &str = "";
 pub const API_VERSION: &str = "1.0.7";
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MultipartRelatedRequestPostResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MultipartRequestPostResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MultipleIdenticalMimeTypesPostResponse {
     /// OK
-    Status200_OK
+    Status200_OK,
 }
 
-
 /// API
 #[async_trait]
 #[allow(clippy::ptr_arg)]
 pub trait Api {
+    /// MultipartRelatedRequestPost - POST /multipart_related_request
+    async fn multipart_related_request_post(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: axum::body::Body,
+    ) -> Result<MultipartRelatedRequestPostResponse, String>;
 
-                /// MultipartRelatedRequestPost - POST /multipart_related_request
+    /// MultipartRequestPost - POST /multipart_request
-                async fn multipart_related_request_post(
+    async fn multipart_request_post(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                    body: axum::body::Body,
+        body: Multipart,
-                ) -> Result<MultipartRelatedRequestPostResponse, String>;
+    ) -> Result<MultipartRequestPostResponse, String>;
-
-
-                /// MultipartRequestPost - POST /multipart_request
-                async fn multipart_request_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                    body: Multipart,
-                ) -> Result<MultipartRequestPostResponse, String>;
-
-
-                /// MultipleIdenticalMimeTypesPost - POST /multiple-identical-mime-types
-                async fn multiple_identical_mime_types_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                    body: axum::body::Body,
-                ) -> Result<MultipleIdenticalMimeTypesPostResponse, String>;
 
+    /// MultipleIdenticalMimeTypesPost - POST /multiple-identical-mime-types
+    async fn multiple_identical_mime_types_post(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: axum::body::Body,
+    ) -> Result<MultipleIdenticalMimeTypesPostResponse, String>;
 }
 
 #[cfg(feature = "server")]

samples/server/petstore/rust-axum/output/multipart-v3/src/models.rs

@@ -7,34 +7,24 @@ use validator::Validate;
 use crate::header;
 use crate::{models, types::*};
 
-      
-      
-      
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct MultipartRelatedRequest {
     #[serde(rename = "object_field")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub object_field: Option<models::MultipartRequestObjectField>,
 
     #[serde(rename = "optional_binary_field")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub optional_binary_field: Option<ByteArray>,
 
     #[serde(rename = "required_binary_field")]
     pub required_binary_field: ByteArray,
-
 }
 
-
 impl MultipartRelatedRequest {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
-    pub fn new(required_binary_field: ByteArray, ) -> MultipartRelatedRequest {
+    pub fn new(required_binary_field: ByteArray) -> MultipartRelatedRequest {
         MultipartRelatedRequest {
             object_field: None,
             optional_binary_field: None,
@@ -88,7 +78,11 @@ impl std::str::FromStr for MultipartRelatedRequest {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing MultipartRelatedRequest".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing MultipartRelatedRequest".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
@@ -110,7 +104,13 @@ impl std::str::FromStr for MultipartRelatedRequest {
         std::result::Result::Ok(MultipartRelatedRequest {
             object_field: intermediate_rep.object_field.into_iter().next(),
             optional_binary_field: intermediate_rep.optional_binary_field.into_iter().next(),
-            required_binary_field: intermediate_rep.required_binary_field.into_iter().next().ok_or_else(|| "required_binary_field missing in MultipartRelatedRequest".to_string())?,
+            required_binary_field: intermediate_rep
+                .required_binary_field
+                .into_iter()
+                .next()
+                .ok_or_else(|| {
+                    "required_binary_field missing in MultipartRelatedRequest".to_string()
+                })?,
         })
     }
 }
@@ -121,13 +121,16 @@ impl std::str::FromStr for MultipartRelatedRequest {
 impl std::convert::TryFrom<header::IntoHeaderValue<MultipartRelatedRequest>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<MultipartRelatedRequest>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<MultipartRelatedRequest>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for MultipartRelatedRequest - value: {} is invalid {}",
+                "Invalid header value for MultipartRelatedRequest - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -138,27 +141,25 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<MultipartRel
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <MultipartRelatedRequest as std::str::FromStr>::from_str(value) {
+                match <MultipartRelatedRequest as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into MultipartRelatedRequest - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into MultipartRelatedRequest - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct MultipartRequestObjectField {
@@ -166,15 +167,13 @@ pub struct MultipartRequestObjectField {
     pub field_a: String,
 
     #[serde(rename = "field_b")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub field_b: Option<Vec<String>>,
-
 }
 
-
 impl MultipartRequestObjectField {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
-    pub fn new(field_a: String, ) -> MultipartRequestObjectField {
+    pub fn new(field_a: String) -> MultipartRequestObjectField {
         MultipartRequestObjectField {
             field_a,
             field_b: None,
@@ -188,18 +187,19 @@ impl MultipartRequestObjectField {
 impl std::string::ToString for MultipartRequestObjectField {
     fn to_string(&self) -> String {
         let params: Vec<Option<String>> = vec![
-
             Some("field_a".to_string()),
             Some(self.field_a.to_string()),
-
-
             self.field_b.as_ref().map(|field_b| {
                 [
                     "field_b".to_string(),
-                    field_b.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","),
+                    field_b
-                ].join(",")
+                        .iter()
+                        .map(|x| x.to_string())
+                        .collect::<Vec<_>>()
+                        .join(","),
+                ]
+                .join(",")
             }),
-
         ];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
@@ -230,7 +230,11 @@ impl std::str::FromStr for MultipartRequestObjectField {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing MultipartRequestObjectField".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing MultipartRequestObjectField".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
@@ -249,7 +253,11 @@ impl std::str::FromStr for MultipartRequestObjectField {
 
         // Use the intermediate representation to return the struct
         std::result::Result::Ok(MultipartRequestObjectField {
-            field_a: intermediate_rep.field_a.into_iter().next().ok_or_else(|| "field_a missing in MultipartRequestObjectField".to_string())?,
+            field_a: intermediate_rep
+                .field_a
+                .into_iter()
+                .next()
+                .ok_or_else(|| "field_a missing in MultipartRequestObjectField".to_string())?,
             field_b: intermediate_rep.field_b.into_iter().next(),
         })
     }
@@ -261,13 +269,16 @@ impl std::str::FromStr for MultipartRequestObjectField {
 impl std::convert::TryFrom<header::IntoHeaderValue<MultipartRequestObjectField>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<MultipartRequestObjectField>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<MultipartRequestObjectField>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for MultipartRequestObjectField - value: {} is invalid {}",
+                "Invalid header value for MultipartRequestObjectField - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -278,41 +289,37 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<MultipartReq
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <MultipartRequestObjectField as std::str::FromStr>::from_str(value) {
+                match <MultipartRequestObjectField as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into MultipartRequestObjectField - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into MultipartRequestObjectField - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct MultipleIdenticalMimeTypesPostRequest {
     #[serde(rename = "binary1")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub binary1: Option<ByteArray>,
 
     #[serde(rename = "binary2")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub binary2: Option<ByteArray>,
-
 }
 
-
 impl MultipleIdenticalMimeTypesPostRequest {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
     pub fn new() -> MultipleIdenticalMimeTypesPostRequest {
@@ -365,7 +372,12 @@ impl std::str::FromStr for MultipleIdenticalMimeTypesPostRequest {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing MultipleIdenticalMimeTypesPostRequest".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing MultipleIdenticalMimeTypesPostRequest"
+                            .to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
@@ -392,10 +404,14 @@ impl std::str::FromStr for MultipleIdenticalMimeTypesPostRequest {
 // Methods for converting between header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest> and HeaderValue
 
 #[cfg(feature = "server")]
-impl std::convert::TryFrom<header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest>> for HeaderValue {
+impl std::convert::TryFrom<header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest>>
+    for HeaderValue
+{
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
              std::result::Result::Ok(value) => std::result::Result::Ok(value),
@@ -407,7 +423,9 @@ impl std::convert::TryFrom<header::IntoHeaderValue<MultipleIdenticalMimeTypesPos
 }
 
 #[cfg(feature = "server")]
-impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest> {
+impl std::convert::TryFrom<HeaderValue>
+    for header::IntoHeaderValue<MultipleIdenticalMimeTypesPostRequest>
+{
     type Error = String;
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
@@ -426,6 +444,3 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<MultipleIden
         }
     }
 }
-
-
-

samples/server/petstore/rust-axum/output/multipart-v3/src/server/mod.rs

@@ -12,10 +12,9 @@ use crate::{header, types::*};
 #[allow(unused_imports)]
 use crate::models;
 
-use crate::{Api,
+use crate::{
-     MultipartRelatedRequestPostResponse,
+    Api, MultipartRelatedRequestPostResponse, MultipartRequestPostResponse,
-     MultipartRequestPostResponse,
+    MultipleIdenticalMimeTypesPostResponse,
-     MultipleIdenticalMimeTypesPostResponse
 };
 
 /// Setup API Server.
@@ -26,216 +25,187 @@ where
 {
     // build our application with a route
     Router::new()
-        .route("/multipart_related_request",
+        .route(
-            post(multipart_related_request_post::<I, A>)
+            "/multipart_related_request",
+            post(multipart_related_request_post::<I, A>),
         )
-        .route("/multipart_request",
+        .route("/multipart_request", post(multipart_request_post::<I, A>))
-            post(multipart_request_post::<I, A>)
+        .route(
-        )
+            "/multiple-identical-mime-types",
-        .route("/multiple-identical-mime-types",
+            post(multiple_identical_mime_types_post::<I, A>),
-            post(multiple_identical_mime_types_post::<I, A>)
         )
         .with_state(api_impl)
 }
 
-
 #[tracing::instrument(skip_all)]
-fn multipart_related_request_post_validation(
+fn multipart_related_request_post_validation() -> std::result::Result<(), ValidationErrors> {
-) -> std::result::Result<(
+    Ok(())
-), ValidationErrors>
-{
-
-Ok((
-))
 }
 
 /// MultipartRelatedRequestPost - POST /multipart_related_request
 #[tracing::instrument(skip_all)]
 async fn multipart_related_request_post<I, A>(
-  method: Method,
+    method: Method,
-  host: Host,
+    host: Host,
-  cookies: CookieJar,
+    cookies: CookieJar,
- State(api_impl): State<I>,
+    State(api_impl): State<I>,
-  body: axum::body::Body,
+    body: axum::body::Body,
 ) -> Result<Response, StatusCode>
-where 
+where
     I: AsRef<A> + Send + Sync,
     A: Api,
 {
+    #[allow(clippy::redundant_closure)]
+    let validation =
+        tokio::task::spawn_blocking(move || multipart_related_request_post_validation())
+            .await
+            .unwrap();
 
-      #[allow(clippy::redundant_closure)]
+    let Ok(()) = validation else {
-      let validation = tokio::task::spawn_blocking(move || 
+        return Response::builder()
-    multipart_related_request_post_validation(
-    )
-  ).await.unwrap();
-
-  let Ok((
-  )) = validation else {
-    return Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body(Body::from(validation.unwrap_err().to_string()))
-            .map_err(|_| StatusCode::BAD_REQUEST); 
+            .map_err(|_| StatusCode::BAD_REQUEST);
-  };
+    };
 
-  let result = api_impl.as_ref().multipart_related_request_post(
+    let result = api_impl
-      method,
+        .as_ref()
-      host,
+        .multipart_related_request_post(method, host, cookies, body)
-      cookies,
+        .await;
-          body,
-  ).await;
 
-  let mut response = Response::builder();
+    let mut response = Response::builder();
 
-  let resp = match result {
+    let resp = match result {
-                                            Ok(rsp) => match rsp {
+        Ok(rsp) => match rsp {
-                                                MultipartRelatedRequestPostResponse::Status201_OK
+            MultipartRelatedRequestPostResponse::Status201_OK => {
-                                                => {
+                let mut response = response.status(201);
+                response.body(Body::empty())
+            }
+        },
+        Err(_) => {
+            // Application code returned an error. This should not happen, as the implementation should
+            // return a valid response.
+            response.status(500).body(Body::empty())
+        }
+    };
 
-                                                  let mut response = response.status(201);
+    resp.map_err(|e| {
-                                                  response.body(Body::empty())
+        error!(error = ?e);
-                                                },
+        StatusCode::INTERNAL_SERVER_ERROR
-                                            },
+    })
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                response.status(500).body(Body::empty())
-                                            },
-                                        };
-
-                                        resp.map_err(|e| { error!(error = ?e); StatusCode::INTERNAL_SERVER_ERROR })
 }
 
-
 #[tracing::instrument(skip_all)]
-fn multipart_request_post_validation(
+fn multipart_request_post_validation() -> std::result::Result<(), ValidationErrors> {
-) -> std::result::Result<(
+    Ok(())
-), ValidationErrors>
-{
-
-Ok((
-))
 }
 
 /// MultipartRequestPost - POST /multipart_request
 #[tracing::instrument(skip_all)]
 async fn multipart_request_post<I, A>(
-  method: Method,
+    method: Method,
-  host: Host,
+    host: Host,
-  cookies: CookieJar,
+    cookies: CookieJar,
- State(api_impl): State<I>,
+    State(api_impl): State<I>,
-  body: Multipart,
+    body: Multipart,
 ) -> Result<Response, StatusCode>
-where 
+where
     I: AsRef<A> + Send + Sync,
     A: Api,
 {
+    #[allow(clippy::redundant_closure)]
+    let validation = tokio::task::spawn_blocking(move || multipart_request_post_validation())
+        .await
+        .unwrap();
 
-      #[allow(clippy::redundant_closure)]
+    let Ok(()) = validation else {
-      let validation = tokio::task::spawn_blocking(move || 
+        return Response::builder()
-    multipart_request_post_validation(
-    )
-  ).await.unwrap();
-
-  let Ok((
-  )) = validation else {
-    return Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body(Body::from(validation.unwrap_err().to_string()))
-            .map_err(|_| StatusCode::BAD_REQUEST); 
+            .map_err(|_| StatusCode::BAD_REQUEST);
-  };
+    };
 
-  let result = api_impl.as_ref().multipart_request_post(
+    let result = api_impl
-      method,
+        .as_ref()
-      host,
+        .multipart_request_post(method, host, cookies, body)
-      cookies,
+        .await;
-          body,
-  ).await;
 
-  let mut response = Response::builder();
+    let mut response = Response::builder();
 
-  let resp = match result {
+    let resp = match result {
-                                            Ok(rsp) => match rsp {
+        Ok(rsp) => match rsp {
-                                                MultipartRequestPostResponse::Status201_OK
+            MultipartRequestPostResponse::Status201_OK => {
-                                                => {
+                let mut response = response.status(201);
+                response.body(Body::empty())
+            }
+        },
+        Err(_) => {
+            // Application code returned an error. This should not happen, as the implementation should
+            // return a valid response.
+            response.status(500).body(Body::empty())
+        }
+    };
 
-                                                  let mut response = response.status(201);
+    resp.map_err(|e| {
-                                                  response.body(Body::empty())
+        error!(error = ?e);
-                                                },
+        StatusCode::INTERNAL_SERVER_ERROR
-                                            },
+    })
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                response.status(500).body(Body::empty())
-                                            },
-                                        };
-
-                                        resp.map_err(|e| { error!(error = ?e); StatusCode::INTERNAL_SERVER_ERROR })
 }
 
-
 #[tracing::instrument(skip_all)]
-fn multiple_identical_mime_types_post_validation(
+fn multiple_identical_mime_types_post_validation() -> std::result::Result<(), ValidationErrors> {
-) -> std::result::Result<(
+    Ok(())
-), ValidationErrors>
-{
-
-Ok((
-))
 }
 
 /// MultipleIdenticalMimeTypesPost - POST /multiple-identical-mime-types
 #[tracing::instrument(skip_all)]
 async fn multiple_identical_mime_types_post<I, A>(
-  method: Method,
+    method: Method,
-  host: Host,
+    host: Host,
-  cookies: CookieJar,
+    cookies: CookieJar,
- State(api_impl): State<I>,
+    State(api_impl): State<I>,
-  body: axum::body::Body,
+    body: axum::body::Body,
 ) -> Result<Response, StatusCode>
-where 
+where
     I: AsRef<A> + Send + Sync,
     A: Api,
 {
+    #[allow(clippy::redundant_closure)]
+    let validation =
+        tokio::task::spawn_blocking(move || multiple_identical_mime_types_post_validation())
+            .await
+            .unwrap();
 
-      #[allow(clippy::redundant_closure)]
+    let Ok(()) = validation else {
-      let validation = tokio::task::spawn_blocking(move || 
+        return Response::builder()
-    multiple_identical_mime_types_post_validation(
-    )
-  ).await.unwrap();
-
-  let Ok((
-  )) = validation else {
-    return Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body(Body::from(validation.unwrap_err().to_string()))
-            .map_err(|_| StatusCode::BAD_REQUEST); 
+            .map_err(|_| StatusCode::BAD_REQUEST);
-  };
+    };
 
-  let result = api_impl.as_ref().multiple_identical_mime_types_post(
+    let result = api_impl
-      method,
+        .as_ref()
-      host,
+        .multiple_identical_mime_types_post(method, host, cookies, body)
-      cookies,
+        .await;
-          body,
-  ).await;
 
-  let mut response = Response::builder();
+    let mut response = Response::builder();
 
-  let resp = match result {
+    let resp = match result {
-                                            Ok(rsp) => match rsp {
+        Ok(rsp) => match rsp {
-                                                MultipleIdenticalMimeTypesPostResponse::Status200_OK
+            MultipleIdenticalMimeTypesPostResponse::Status200_OK => {
-                                                => {
+                let mut response = response.status(200);
+                response.body(Body::empty())
+            }
+        },
+        Err(_) => {
+            // Application code returned an error. This should not happen, as the implementation should
+            // return a valid response.
+            response.status(500).body(Body::empty())
+        }
+    };
 
-                                                  let mut response = response.status(200);
+    resp.map_err(|e| {
-                                                  response.body(Body::empty())
+        error!(error = ?e);
-                                                },
+        StatusCode::INTERNAL_SERVER_ERROR
-                                            },
+    })
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                response.status(500).body(Body::empty())
-                                            },
-                                        };
-
-                                        resp.map_err(|e| { error!(error = ?e); StatusCode::INTERNAL_SERVER_ERROR })
 }
-

samples/server/petstore/rust-axum/output/openapi-v3/src/header.rs

@@ -30,11 +30,16 @@ macro_rules! ihv_generate {
                 match hdr_value.to_str() {
                     Ok(hdr_value) => match hdr_value.parse::<$t>() {
                         Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!("Unable to parse {} as a string: {}",
+                        Err(e) => Err(format!(
-                            stringify!($t), e)),
+                            "Unable to parse {} as a string: {}",
+                            stringify!($t),
+                            e
+                        )),
                     },
-                    Err(e) => Err(format!("Unable to parse header {:?} as a string - {}",
+                    Err(e) => Err(format!(
-                        hdr_value, e)),
+                        "Unable to parse header {:?} as a string - {}",
+                        hdr_value, e
+                    )),
                 }
             }
         }
@@ -69,14 +74,17 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(
                 hdr_value
-                .split(',')
+                    .split(',')
-                .filter_map(|x| match x.trim() {
+                    .filter_map(|x| match x.trim() {
-                    "" => None,
+                        "" => None,
-                    y => Some(y.to_string()),
+                        y => Some(y.to_string()),
-                })
+                    })
-                .collect())),
+                    .collect(),
-            Err(e) => Err(format!("Unable to parse header: {:?} as a string - {}",
+            )),
-                hdr_value, e)),
+            Err(e) => Err(format!(
+                "Unable to parse header: {:?} as a string - {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -85,11 +93,13 @@ impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
     type Error = String;
 
     fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-       match HeaderValue::from_str(&hdr_value.0.join(", ")) {
+        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-           Ok(hdr_value) => Ok(hdr_value),
+            Ok(hdr_value) => Ok(hdr_value),
-           Err(e) => Err(format!("Unable to convert {:?} into a header - {}",
+            Err(e) => Err(format!(
-               hdr_value, e))
+                "Unable to convert {:?} into a header - {}",
-       }
+                hdr_value, e
+            )),
+        }
     }
 }
 
@@ -101,8 +111,7 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
     fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}",
+            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-                hdr_value, e)),
         }
     }
 }
@@ -113,8 +122,10 @@ impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -128,11 +139,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match hdr_value.parse() {
                 Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}",
+                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -143,8 +155,10 @@ impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0.to_string()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert: {:?} into a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert: {:?} into a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -158,11 +172,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
                 Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}",
+                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert header {:?} to string {}",
+            Err(e) => Err(format!(
-                    hdr_value, e)),
+                "Unable to convert header {:?} to string {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -173,8 +188,10 @@ impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} to a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} to a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }

samples/server/petstore/rust-axum/output/openapi-v3/src/lib.rs

@@ -1,4 +1,12 @@
-#![allow(missing_docs, trivial_casts, unused_variables, unused_mut, unused_imports, unused_extern_crates, non_camel_case_types)]
+#![allow(
+    missing_docs,
+    trivial_casts,
+    unused_variables,
+    unused_mut,
+    unused_imports,
+    unused_extern_crates,
+    non_camel_case_types
+)]
 #![allow(unused_imports, unused_attributes)]
 #![allow(clippy::derive_partial_eq_without_eq, clippy::disallowed_names)]
 
@@ -14,569 +22,488 @@ use types::*;
 pub const BASE_PATH: &str = "";
 pub const API_VERSION: &str = "1.0.7";
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum AnyOfGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success(models::AnyOfObject),
-    (models::AnyOfObject)
-    ,
     /// AlternateSuccess
-    Status201_AlternateSuccess
+    Status201_AlternateSuccess(models::Model12345AnyOfObject),
-    (models::Model12345AnyOfObject)
-    ,
     /// AnyOfSuccess
-    Status202_AnyOfSuccess
+    Status202_AnyOfSuccess(models::AnyOfGet202Response),
-    (models::AnyOfGet202Response)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum CallbackWithHeaderPostResponse {
     /// OK
-    Status204_OK
+    Status204_OK,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum ComplexQueryParamGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum EnumInPathPathParamGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum JsonComplexQueryParamGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MandatoryRequestHeaderGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MergePatchJsonGetResponse {
     /// merge-patch+json-encoded response
-    Status200_Merge
+    Status200_Merge(models::AnotherXmlObject),
-    (models::AnotherXmlObject)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MultigetGetResponse {
     /// JSON rsp
-    Status200_JSONRsp
+    Status200_JSONRsp(models::AnotherXmlObject),
-    (models::AnotherXmlObject)
-    ,
     /// XML rsp
-    Status201_XMLRsp
+    Status201_XMLRsp(String),
-    (String)
-    ,
     /// octet rsp
-    Status202_OctetRsp
+    Status202_OctetRsp(ByteArray),
-    (ByteArray)
-    ,
     /// string rsp
-    Status203_StringRsp
+    Status203_StringRsp(String),
-    (String)
-    ,
     /// Duplicate Response long text. One.
-    Status204_DuplicateResponseLongText
+    Status204_DuplicateResponseLongText(models::AnotherXmlObject),
-    (models::AnotherXmlObject)
-    ,
     /// Duplicate Response long text. Two.
-    Status205_DuplicateResponseLongText
+    Status205_DuplicateResponseLongText(models::AnotherXmlObject),
-    (models::AnotherXmlObject)
-    ,
     /// Duplicate Response long text. Three.
-    Status206_DuplicateResponseLongText
+    Status206_DuplicateResponseLongText(models::AnotherXmlObject),
-    (models::AnotherXmlObject)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum MultipleAuthSchemeGetResponse {
     /// Check that limiting to multiple required auth schemes works
-    Status200_CheckThatLimitingToMultipleRequiredAuthSchemesWorks
+    Status200_CheckThatLimitingToMultipleRequiredAuthSchemesWorks,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum OneOfGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success(models::OneOfGet200Response),
-    (models::OneOfGet200Response)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum OverrideServerGetResponse {
     /// Success.
-    Status204_Success
+    Status204_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum ParamgetGetResponse {
     /// JSON rsp
-    Status200_JSONRsp
+    Status200_JSONRsp(models::AnotherXmlObject),
-    (models::AnotherXmlObject)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum ReadonlyAuthSchemeGetResponse {
     /// Check that limiting to a single required auth scheme works
-    Status200_CheckThatLimitingToASingleRequiredAuthSchemeWorks
+    Status200_CheckThatLimitingToASingleRequiredAuthSchemeWorks,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum RegisterCallbackPostResponse {
     /// OK
-    Status204_OK
+    Status204_OK,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum RequiredOctetStreamPutResponse {
     /// OK
-    Status200_OK
+    Status200_OK,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum ResponsesWithHeadersGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success {
-    {
         body: String,
-        success_info:
+        success_info: String,
-        String
+        bool_header: Option<bool>,
-        ,
+        object_header: Option<models::ObjectHeader>,
-        bool_header:
+    },
-        Option<
-        bool
-        >
-        ,
-        object_header:
-        Option<
-        models::ObjectHeader
-        >
-    }
-    ,
     /// Precondition Failed
-    Status412_PreconditionFailed
+    Status412_PreconditionFailed {
-    {
+        further_info: Option<String>,
-        further_info:
+        failure_info: Option<String>,
-        Option<
+    },
-        String
-        >
-        ,
-        failure_info:
-        Option<
-        String
-        >
-    }
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum Rfc7807GetResponse {
     /// OK
-    Status204_OK
+    Status204_OK(models::ObjectWithArrayOfObjects),
-    (models::ObjectWithArrayOfObjects)
-    ,
     /// NotFound
-    Status404_NotFound
+    Status404_NotFound(models::ObjectWithArrayOfObjects),
-    (models::ObjectWithArrayOfObjects)
-    ,
     /// NotAcceptable
-    Status406_NotAcceptable
+    Status406_NotAcceptable(String),
-    (String)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum UntypedPropertyGetResponse {
     /// Check that untyped properties works
-    Status200_CheckThatUntypedPropertiesWorks
+    Status200_CheckThatUntypedPropertiesWorks,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum UuidGetResponse {
     /// Duplicate Response long text. One.
-    Status200_DuplicateResponseLongText
+    Status200_DuplicateResponseLongText(uuid::Uuid),
-    (uuid::Uuid)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum XmlExtraPostResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
-    ,
     /// Bad Request
-    Status400_BadRequest
+    Status400_BadRequest,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum XmlOtherPostResponse {
     /// OK
-    Status201_OK
+    Status201_OK(String),
-    (String)
-    ,
     /// Bad Request
-    Status400_BadRequest
+    Status400_BadRequest,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum XmlOtherPutResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
-    ,
     /// Bad Request
-    Status400_BadRequest
+    Status400_BadRequest,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum XmlPostResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
-    ,
     /// Bad Request
-    Status400_BadRequest
+    Status400_BadRequest,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum XmlPutResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
-    ,
     /// Bad Request
-    Status400_BadRequest
+    Status400_BadRequest,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum CreateRepoResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum GetRepoInfoResponse {
     /// OK
-    Status200_OK
+    Status200_OK(String),
-    (String)
 }
 
-
 /// API
 #[async_trait]
 #[allow(clippy::ptr_arg)]
 pub trait Api {
+    /// AnyOfGet - GET /any-of
+    async fn any_of_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        query_params: models::AnyOfGetQueryParams,
+    ) -> Result<AnyOfGetResponse, String>;
 
-                /// AnyOfGet - GET /any-of
+    /// CallbackWithHeaderPost - POST /callback-with-header
-                async fn any_of_get(
+    async fn callback_with_header_post(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  query_params: models::AnyOfGetQueryParams,
+        query_params: models::CallbackWithHeaderPostQueryParams,
-                ) -> Result<AnyOfGetResponse, String>;
+    ) -> Result<CallbackWithHeaderPostResponse, String>;
 
+    /// ComplexQueryParamGet - GET /complex-query-param
+    async fn complex_query_param_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        query_params: models::ComplexQueryParamGetQueryParams,
+    ) -> Result<ComplexQueryParamGetResponse, String>;
 
-                /// CallbackWithHeaderPost - POST /callback-with-header
+    /// EnumInPathPathParamGet - GET /enum_in_path/{path_param}
-                async fn callback_with_header_post(
+    async fn enum_in_path_path_param_get(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  query_params: models::CallbackWithHeaderPostQueryParams,
+        path_params: models::EnumInPathPathParamGetPathParams,
-                ) -> Result<CallbackWithHeaderPostResponse, String>;
+    ) -> Result<EnumInPathPathParamGetResponse, String>;
 
+    /// JsonComplexQueryParamGet - GET /json-complex-query-param
+    async fn json_complex_query_param_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        query_params: models::JsonComplexQueryParamGetQueryParams,
+    ) -> Result<JsonComplexQueryParamGetResponse, String>;
 
-                /// ComplexQueryParamGet - GET /complex-query-param
+    /// MandatoryRequestHeaderGet - GET /mandatory-request-header
-                async fn complex_query_param_get(
+    async fn mandatory_request_header_get(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  query_params: models::ComplexQueryParamGetQueryParams,
+        header_params: models::MandatoryRequestHeaderGetHeaderParams,
-                ) -> Result<ComplexQueryParamGetResponse, String>;
+    ) -> Result<MandatoryRequestHeaderGetResponse, String>;
 
+    /// MergePatchJsonGet - GET /merge-patch-json
+    async fn merge_patch_json_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<MergePatchJsonGetResponse, String>;
 
-                /// EnumInPathPathParamGet - GET /enum_in_path/{path_param}
+    /// Get some stuff..
-                async fn enum_in_path_path_param_get(
+    ///
-                &self,
+    /// MultigetGet - GET /multiget
-                method: Method,
+    async fn multiget_get(
-                host: Host,
+        &self,
-                cookies: CookieJar,
+        method: Method,
-                  path_params: models::EnumInPathPathParamGetPathParams,
+        host: Host,
-                ) -> Result<EnumInPathPathParamGetResponse, String>;
+        cookies: CookieJar,
+    ) -> Result<MultigetGetResponse, String>;
 
+    /// MultipleAuthSchemeGet - GET /multiple_auth_scheme
+    async fn multiple_auth_scheme_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<MultipleAuthSchemeGetResponse, String>;
 
-                /// JsonComplexQueryParamGet - GET /json-complex-query-param
+    /// OneOfGet - GET /one-of
-                async fn json_complex_query_param_get(
+    async fn one_of_get(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  query_params: models::JsonComplexQueryParamGetQueryParams,
+    ) -> Result<OneOfGetResponse, String>;
-                ) -> Result<JsonComplexQueryParamGetResponse, String>;
 
+    /// OverrideServerGet - GET /override-server
+    async fn override_server_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<OverrideServerGetResponse, String>;
 
-                /// MandatoryRequestHeaderGet - GET /mandatory-request-header
+    /// Get some stuff with parameters..
-                async fn mandatory_request_header_get(
+    ///
-                &self,
+    /// ParamgetGet - GET /paramget
-                method: Method,
+    async fn paramget_get(
-                host: Host,
+        &self,
-                cookies: CookieJar,
+        method: Method,
-                  header_params: models::MandatoryRequestHeaderGetHeaderParams,
+        host: Host,
-                ) -> Result<MandatoryRequestHeaderGetResponse, String>;
+        cookies: CookieJar,
+        query_params: models::ParamgetGetQueryParams,
+    ) -> Result<ParamgetGetResponse, String>;
 
+    /// ReadonlyAuthSchemeGet - GET /readonly_auth_scheme
+    async fn readonly_auth_scheme_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<ReadonlyAuthSchemeGetResponse, String>;
 
-                /// MergePatchJsonGet - GET /merge-patch-json
+    /// RegisterCallbackPost - POST /register-callback
-                async fn merge_patch_json_get(
+    async fn register_callback_post(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<MergePatchJsonGetResponse, String>;
+        query_params: models::RegisterCallbackPostQueryParams,
+    ) -> Result<RegisterCallbackPostResponse, String>;
 
+    /// RequiredOctetStreamPut - PUT /required_octet_stream
+    async fn required_octet_stream_put(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: Bytes,
+    ) -> Result<RequiredOctetStreamPutResponse, String>;
 
-                /// Get some stuff..
+    /// ResponsesWithHeadersGet - GET /responses_with_headers
-                ///
+    async fn responses_with_headers_get(
-                /// MultigetGet - GET /multiget
+        &self,
-                async fn multiget_get(
+        method: Method,
-                &self,
+        host: Host,
-                method: Method,
+        cookies: CookieJar,
-                host: Host,
+    ) -> Result<ResponsesWithHeadersGetResponse, String>;
-                cookies: CookieJar,
-                ) -> Result<MultigetGetResponse, String>;
 
+    /// Rfc7807Get - GET /rfc7807
+    async fn rfc7807_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<Rfc7807GetResponse, String>;
 
-                /// MultipleAuthSchemeGet - GET /multiple_auth_scheme
+    /// UntypedPropertyGet - GET /untyped_property
-                async fn multiple_auth_scheme_get(
+    async fn untyped_property_get(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<MultipleAuthSchemeGetResponse, String>;
+        body: Option<models::ObjectUntypedProps>,
+    ) -> Result<UntypedPropertyGetResponse, String>;
 
+    /// UuidGet - GET /uuid
+    async fn uuid_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<UuidGetResponse, String>;
 
-                /// OneOfGet - GET /one-of
+    /// XmlExtraPost - POST /xml_extra
-                async fn one_of_get(
+    async fn xml_extra_post(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<OneOfGetResponse, String>;
+        body: Bytes,
+    ) -> Result<XmlExtraPostResponse, String>;
 
+    /// XmlOtherPost - POST /xml_other
+    async fn xml_other_post(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: Bytes,
+    ) -> Result<XmlOtherPostResponse, String>;
 
-                /// OverrideServerGet - GET /override-server
+    /// XmlOtherPut - PUT /xml_other
-                async fn override_server_get(
+    async fn xml_other_put(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<OverrideServerGetResponse, String>;
+        body: Bytes,
+    ) -> Result<XmlOtherPutResponse, String>;
 
+    /// Post an array.
+    ///
+    /// XmlPost - POST /xml
+    async fn xml_post(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: Bytes,
+    ) -> Result<XmlPostResponse, String>;
 
-                /// Get some stuff with parameters..
+    /// XmlPut - PUT /xml
-                ///
+    async fn xml_put(
-                /// ParamgetGet - GET /paramget
+        &self,
-                async fn paramget_get(
+        method: Method,
-                &self,
+        host: Host,
-                method: Method,
+        cookies: CookieJar,
-                host: Host,
+        body: Bytes,
-                cookies: CookieJar,
+    ) -> Result<XmlPutResponse, String>;
-                  query_params: models::ParamgetGetQueryParams,
-                ) -> Result<ParamgetGetResponse, String>;
 
+    /// CreateRepo - POST /repos
+    async fn create_repo(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: models::ObjectParam,
+    ) -> Result<CreateRepoResponse, String>;
 
-                /// ReadonlyAuthSchemeGet - GET /readonly_auth_scheme
+    /// GetRepoInfo - GET /repos/{repoId}
-                async fn readonly_auth_scheme_get(
+    async fn get_repo_info(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<ReadonlyAuthSchemeGetResponse, String>;
+        path_params: models::GetRepoInfoPathParams,
-
+    ) -> Result<GetRepoInfoResponse, String>;
-
-                /// RegisterCallbackPost - POST /register-callback
-                async fn register_callback_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  query_params: models::RegisterCallbackPostQueryParams,
-                ) -> Result<RegisterCallbackPostResponse, String>;
-
-
-                /// RequiredOctetStreamPut - PUT /required_octet_stream
-                async fn required_octet_stream_put(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Bytes,
-                ) -> Result<RequiredOctetStreamPutResponse, String>;
-
-
-                /// ResponsesWithHeadersGet - GET /responses_with_headers
-                async fn responses_with_headers_get(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                ) -> Result<ResponsesWithHeadersGetResponse, String>;
-
-
-                /// Rfc7807Get - GET /rfc7807
-                async fn rfc7807_get(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                ) -> Result<Rfc7807GetResponse, String>;
-
-
-                /// UntypedPropertyGet - GET /untyped_property
-                async fn untyped_property_get(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Option<models::ObjectUntypedProps>,
-                ) -> Result<UntypedPropertyGetResponse, String>;
-
-
-                /// UuidGet - GET /uuid
-                async fn uuid_get(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                ) -> Result<UuidGetResponse, String>;
-
-
-                /// XmlExtraPost - POST /xml_extra
-                async fn xml_extra_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Bytes,
-                ) -> Result<XmlExtraPostResponse, String>;
-
-
-                /// XmlOtherPost - POST /xml_other
-                async fn xml_other_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Bytes,
-                ) -> Result<XmlOtherPostResponse, String>;
-
-
-                /// XmlOtherPut - PUT /xml_other
-                async fn xml_other_put(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Bytes,
-                ) -> Result<XmlOtherPutResponse, String>;
-
-
-                /// Post an array.
-                ///
-                /// XmlPost - POST /xml
-                async fn xml_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Bytes,
-                ) -> Result<XmlPostResponse, String>;
-
-
-                /// XmlPut - PUT /xml
-                async fn xml_put(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Bytes,
-                ) -> Result<XmlPutResponse, String>;
-
-
-                /// CreateRepo - POST /repos
-                async fn create_repo(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: models::ObjectParam,
-                ) -> Result<CreateRepoResponse, String>;
-
-
-                /// GetRepoInfo - GET /repos/{repoId}
-                async fn get_repo_info(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  path_params: models::GetRepoInfoPathParams,
-                ) -> Result<GetRepoInfoResponse, String>;
-
 }
 
 #[cfg(feature = "server")]

samples/server/petstore/rust-axum/output/petstore-with-fake-endpoints-models-for-testing/src/header.rs

@@ -30,11 +30,16 @@ macro_rules! ihv_generate {
                 match hdr_value.to_str() {
                     Ok(hdr_value) => match hdr_value.parse::<$t>() {
                         Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!("Unable to parse {} as a string: {}",
+                        Err(e) => Err(format!(
-                            stringify!($t), e)),
+                            "Unable to parse {} as a string: {}",
+                            stringify!($t),
+                            e
+                        )),
                     },
-                    Err(e) => Err(format!("Unable to parse header {:?} as a string - {}",
+                    Err(e) => Err(format!(
-                        hdr_value, e)),
+                        "Unable to parse header {:?} as a string - {}",
+                        hdr_value, e
+                    )),
                 }
             }
         }
@@ -69,14 +74,17 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(
                 hdr_value
-                .split(',')
+                    .split(',')
-                .filter_map(|x| match x.trim() {
+                    .filter_map(|x| match x.trim() {
-                    "" => None,
+                        "" => None,
-                    y => Some(y.to_string()),
+                        y => Some(y.to_string()),
-                })
+                    })
-                .collect())),
+                    .collect(),
-            Err(e) => Err(format!("Unable to parse header: {:?} as a string - {}",
+            )),
-                hdr_value, e)),
+            Err(e) => Err(format!(
+                "Unable to parse header: {:?} as a string - {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -85,11 +93,13 @@ impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
     type Error = String;
 
     fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-       match HeaderValue::from_str(&hdr_value.0.join(", ")) {
+        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-           Ok(hdr_value) => Ok(hdr_value),
+            Ok(hdr_value) => Ok(hdr_value),
-           Err(e) => Err(format!("Unable to convert {:?} into a header - {}",
+            Err(e) => Err(format!(
-               hdr_value, e))
+                "Unable to convert {:?} into a header - {}",
-       }
+                hdr_value, e
+            )),
+        }
     }
 }
 
@@ -101,8 +111,7 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
     fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}",
+            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-                hdr_value, e)),
         }
     }
 }
@@ -113,8 +122,10 @@ impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -128,11 +139,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match hdr_value.parse() {
                 Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}",
+                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -143,8 +155,10 @@ impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0.to_string()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert: {:?} into a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert: {:?} into a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -158,11 +172,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
                 Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}",
+                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert header {:?} to string {}",
+            Err(e) => Err(format!(
-                    hdr_value, e)),
+                "Unable to convert header {:?} to string {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -173,8 +188,10 @@ impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} to a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} to a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }

samples/server/petstore/rust-axum/output/petstore/src/header.rs

@@ -30,11 +30,16 @@ macro_rules! ihv_generate {
                 match hdr_value.to_str() {
                     Ok(hdr_value) => match hdr_value.parse::<$t>() {
                         Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!("Unable to parse {} as a string: {}",
+                        Err(e) => Err(format!(
-                            stringify!($t), e)),
+                            "Unable to parse {} as a string: {}",
+                            stringify!($t),
+                            e
+                        )),
                     },
-                    Err(e) => Err(format!("Unable to parse header {:?} as a string - {}",
+                    Err(e) => Err(format!(
-                        hdr_value, e)),
+                        "Unable to parse header {:?} as a string - {}",
+                        hdr_value, e
+                    )),
                 }
             }
         }
@@ -69,14 +74,17 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(
                 hdr_value
-                .split(',')
+                    .split(',')
-                .filter_map(|x| match x.trim() {
+                    .filter_map(|x| match x.trim() {
-                    "" => None,
+                        "" => None,
-                    y => Some(y.to_string()),
+                        y => Some(y.to_string()),
-                })
+                    })
-                .collect())),
+                    .collect(),
-            Err(e) => Err(format!("Unable to parse header: {:?} as a string - {}",
+            )),
-                hdr_value, e)),
+            Err(e) => Err(format!(
+                "Unable to parse header: {:?} as a string - {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -85,11 +93,13 @@ impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
     type Error = String;
 
     fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-       match HeaderValue::from_str(&hdr_value.0.join(", ")) {
+        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-           Ok(hdr_value) => Ok(hdr_value),
+            Ok(hdr_value) => Ok(hdr_value),
-           Err(e) => Err(format!("Unable to convert {:?} into a header - {}",
+            Err(e) => Err(format!(
-               hdr_value, e))
+                "Unable to convert {:?} into a header - {}",
-       }
+                hdr_value, e
+            )),
+        }
     }
 }
 
@@ -101,8 +111,7 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
     fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}",
+            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-                hdr_value, e)),
         }
     }
 }
@@ -113,8 +122,10 @@ impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -128,11 +139,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match hdr_value.parse() {
                 Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}",
+                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -143,8 +155,10 @@ impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0.to_string()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert: {:?} into a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert: {:?} into a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -158,11 +172,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
                 Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}",
+                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert header {:?} to string {}",
+            Err(e) => Err(format!(
-                    hdr_value, e)),
+                "Unable to convert header {:?} to string {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -173,8 +188,10 @@ impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} to a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} to a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }

samples/server/petstore/rust-axum/output/petstore/src/lib.rs

@@ -1,4 +1,12 @@
-#![allow(missing_docs, trivial_casts, unused_variables, unused_mut, unused_imports, unused_extern_crates, non_camel_case_types)]
+#![allow(
+    missing_docs,
+    trivial_casts,
+    unused_variables,
+    unused_mut,
+    unused_imports,
+    unused_extern_crates,
+    non_camel_case_types
+)]
 #![allow(unused_imports, unused_attributes)]
 #![allow(clippy::derive_partial_eq_without_eq, clippy::disallowed_names)]
 
@@ -14,490 +22,429 @@ use types::*;
 pub const BASE_PATH: &str = "/v2";
 pub const API_VERSION: &str = "1.0.0";
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum AddPetResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid input
-    Status405_InvalidInput
+    Status405_InvalidInput,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum DeletePetResponse {
     /// Invalid pet value
-    Status400_InvalidPetValue
+    Status400_InvalidPetValue,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum FindPetsByStatusResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid status value
-    Status400_InvalidStatusValue
+    Status400_InvalidStatusValue,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum FindPetsByTagsResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid tag value
-    Status400_InvalidTagValue
+    Status400_InvalidTagValue,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum GetPetByIdResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid ID supplied
-    Status400_InvalidIDSupplied
+    Status400_InvalidIDSupplied,
-    ,
     /// Pet not found
-    Status404_PetNotFound
+    Status404_PetNotFound,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum UpdatePetResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid ID supplied
-    Status400_InvalidIDSupplied
+    Status400_InvalidIDSupplied,
-    ,
     /// Pet not found
-    Status404_PetNotFound
+    Status404_PetNotFound,
-    ,
     /// Validation exception
-    Status405_ValidationException
+    Status405_ValidationException,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum UpdatePetWithFormResponse {
     /// Invalid input
-    Status405_InvalidInput
+    Status405_InvalidInput,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum UploadFileResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(models::ApiResponse),
-    (models::ApiResponse)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum DeleteOrderResponse {
     /// Invalid ID supplied
-    Status400_InvalidIDSupplied
+    Status400_InvalidIDSupplied,
-    ,
     /// Order not found
-    Status404_OrderNotFound
+    Status404_OrderNotFound,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum GetInventoryResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(std::collections::HashMap<String, i32>),
-    (std::collections::HashMap<String, i32>)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum GetOrderByIdResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid ID supplied
-    Status400_InvalidIDSupplied
+    Status400_InvalidIDSupplied,
-    ,
     /// Order not found
-    Status404_OrderNotFound
+    Status404_OrderNotFound,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum PlaceOrderResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid Order
-    Status400_InvalidOrder
+    Status400_InvalidOrder,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum CreateUserResponse {
     /// successful operation
-    Status0_SuccessfulOperation
+    Status0_SuccessfulOperation,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum CreateUsersWithArrayInputResponse {
     /// successful operation
-    Status0_SuccessfulOperation
+    Status0_SuccessfulOperation,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum CreateUsersWithListInputResponse {
     /// successful operation
-    Status0_SuccessfulOperation
+    Status0_SuccessfulOperation,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum DeleteUserResponse {
     /// Invalid username supplied
-    Status400_InvalidUsernameSupplied
+    Status400_InvalidUsernameSupplied,
-    ,
     /// User not found
-    Status404_UserNotFound
+    Status404_UserNotFound,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum GetUserByNameResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation(String),
-    (String)
-    ,
     /// Invalid username supplied
-    Status400_InvalidUsernameSupplied
+    Status400_InvalidUsernameSupplied,
-    ,
     /// User not found
-    Status404_UserNotFound
+    Status404_UserNotFound,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum LoginUserResponse {
     /// successful operation
-    Status200_SuccessfulOperation
+    Status200_SuccessfulOperation {
-    {
         body: String,
-        set_cookie:
+        set_cookie: Option<String>,
-        Option<
+        x_rate_limit: Option<i32>,
-        String
+        x_expires_after: Option<chrono::DateTime<chrono::Utc>>,
-        >
+    },
-        ,
-        x_rate_limit:
-        Option<
-        i32
-        >
-        ,
-        x_expires_after:
-        Option<
-        chrono::DateTime::<chrono::Utc>
-        >
-    }
-    ,
     /// Invalid username/password supplied
-    Status400_InvalidUsername
+    Status400_InvalidUsername,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum LogoutUserResponse {
     /// successful operation
-    Status0_SuccessfulOperation
+    Status0_SuccessfulOperation,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum UpdateUserResponse {
     /// Invalid user supplied
-    Status400_InvalidUserSupplied
+    Status400_InvalidUserSupplied,
-    ,
     /// User not found
-    Status404_UserNotFound
+    Status404_UserNotFound,
 }
 
-
 /// API
 #[async_trait]
 #[allow(clippy::ptr_arg)]
 pub trait Api {
+    /// Add a new pet to the store.
+    ///
+    /// AddPet - POST /v2/pet
+    async fn add_pet(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: models::Pet,
+    ) -> Result<AddPetResponse, String>;
 
-                /// Add a new pet to the store.
+    /// Deletes a pet.
-                ///
+    ///
-                /// AddPet - POST /v2/pet
+    /// DeletePet - DELETE /v2/pet/{petId}
-                async fn add_pet(
+    async fn delete_pet(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                        body: models::Pet,
+        header_params: models::DeletePetHeaderParams,
-                ) -> Result<AddPetResponse, String>;
+        path_params: models::DeletePetPathParams,
+    ) -> Result<DeletePetResponse, String>;
 
+    /// Finds Pets by status.
+    ///
+    /// FindPetsByStatus - GET /v2/pet/findByStatus
+    async fn find_pets_by_status(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        query_params: models::FindPetsByStatusQueryParams,
+    ) -> Result<FindPetsByStatusResponse, String>;
 
-                /// Deletes a pet.
+    /// Finds Pets by tags.
-                ///
+    ///
-                /// DeletePet - DELETE /v2/pet/{petId}
+    /// FindPetsByTags - GET /v2/pet/findByTags
-                async fn delete_pet(
+    async fn find_pets_by_tags(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  header_params: models::DeletePetHeaderParams,
+        query_params: models::FindPetsByTagsQueryParams,
-                  path_params: models::DeletePetPathParams,
+    ) -> Result<FindPetsByTagsResponse, String>;
-                ) -> Result<DeletePetResponse, String>;
 
+    /// Find pet by ID.
+    ///
+    /// GetPetById - GET /v2/pet/{petId}
+    async fn get_pet_by_id(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        path_params: models::GetPetByIdPathParams,
+    ) -> Result<GetPetByIdResponse, String>;
 
-                /// Finds Pets by status.
+    /// Update an existing pet.
-                ///
+    ///
-                /// FindPetsByStatus - GET /v2/pet/findByStatus
+    /// UpdatePet - PUT /v2/pet
-                async fn find_pets_by_status(
+    async fn update_pet(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  query_params: models::FindPetsByStatusQueryParams,
+        body: models::Pet,
-                ) -> Result<FindPetsByStatusResponse, String>;
+    ) -> Result<UpdatePetResponse, String>;
 
+    /// Updates a pet in the store with form data.
+    ///
+    /// UpdatePetWithForm - POST /v2/pet/{petId}
+    async fn update_pet_with_form(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        path_params: models::UpdatePetWithFormPathParams,
+    ) -> Result<UpdatePetWithFormResponse, String>;
 
-                /// Finds Pets by tags.
+    /// uploads an image.
-                ///
+    ///
-                /// FindPetsByTags - GET /v2/pet/findByTags
+    /// UploadFile - POST /v2/pet/{petId}/uploadImage
-                async fn find_pets_by_tags(
+    async fn upload_file(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  query_params: models::FindPetsByTagsQueryParams,
+        path_params: models::UploadFilePathParams,
-                ) -> Result<FindPetsByTagsResponse, String>;
+        body: Multipart,
+    ) -> Result<UploadFileResponse, String>;
 
+    /// Delete purchase order by ID.
+    ///
+    /// DeleteOrder - DELETE /v2/store/order/{orderId}
+    async fn delete_order(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        path_params: models::DeleteOrderPathParams,
+    ) -> Result<DeleteOrderResponse, String>;
 
-                /// Find pet by ID.
+    /// Returns pet inventories by status.
-                ///
+    ///
-                /// GetPetById - GET /v2/pet/{petId}
+    /// GetInventory - GET /v2/store/inventory
-                async fn get_pet_by_id(
+    async fn get_inventory(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  path_params: models::GetPetByIdPathParams,
+    ) -> Result<GetInventoryResponse, String>;
-                ) -> Result<GetPetByIdResponse, String>;
 
+    /// Find purchase order by ID.
+    ///
+    /// GetOrderById - GET /v2/store/order/{orderId}
+    async fn get_order_by_id(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        path_params: models::GetOrderByIdPathParams,
+    ) -> Result<GetOrderByIdResponse, String>;
 
-                /// Update an existing pet.
+    /// Place an order for a pet.
-                ///
+    ///
-                /// UpdatePet - PUT /v2/pet
+    /// PlaceOrder - POST /v2/store/order
-                async fn update_pet(
+    async fn place_order(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                        body: models::Pet,
+        body: models::Order,
-                ) -> Result<UpdatePetResponse, String>;
+    ) -> Result<PlaceOrderResponse, String>;
 
+    /// Create user.
+    ///
+    /// CreateUser - POST /v2/user
+    async fn create_user(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: models::User,
+    ) -> Result<CreateUserResponse, String>;
 
-                /// Updates a pet in the store with form data.
+    /// Creates list of users with given input array.
-                ///
+    ///
-                /// UpdatePetWithForm - POST /v2/pet/{petId}
+    /// CreateUsersWithArrayInput - POST /v2/user/createWithArray
-                async fn update_pet_with_form(
+    async fn create_users_with_array_input(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  path_params: models::UpdatePetWithFormPathParams,
+        body: Vec<models::User>,
-                ) -> Result<UpdatePetWithFormResponse, String>;
+    ) -> Result<CreateUsersWithArrayInputResponse, String>;
 
+    /// Creates list of users with given input array.
+    ///
+    /// CreateUsersWithListInput - POST /v2/user/createWithList
+    async fn create_users_with_list_input(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: Vec<models::User>,
+    ) -> Result<CreateUsersWithListInputResponse, String>;
 
-                /// uploads an image.
+    /// Delete user.
-                ///
+    ///
-                /// UploadFile - POST /v2/pet/{petId}/uploadImage
+    /// DeleteUser - DELETE /v2/user/{username}
-                async fn upload_file(
+    async fn delete_user(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  path_params: models::UploadFilePathParams,
+        path_params: models::DeleteUserPathParams,
-                    body: Multipart,
+    ) -> Result<DeleteUserResponse, String>;
-                ) -> Result<UploadFileResponse, String>;
 
+    /// Get user by user name.
+    ///
+    /// GetUserByName - GET /v2/user/{username}
+    async fn get_user_by_name(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        path_params: models::GetUserByNamePathParams,
+    ) -> Result<GetUserByNameResponse, String>;
 
-                /// Delete purchase order by ID.
+    /// Logs user into the system.
-                ///
+    ///
-                /// DeleteOrder - DELETE /v2/store/order/{orderId}
+    /// LoginUser - GET /v2/user/login
-                async fn delete_order(
+    async fn login_user(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                  path_params: models::DeleteOrderPathParams,
+        query_params: models::LoginUserQueryParams,
-                ) -> Result<DeleteOrderResponse, String>;
+    ) -> Result<LoginUserResponse, String>;
 
+    /// Logs out current logged in user session.
+    ///
+    /// LogoutUser - GET /v2/user/logout
+    async fn logout_user(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<LogoutUserResponse, String>;
 
-                /// Returns pet inventories by status.
+    /// Updated user.
-                ///
+    ///
-                /// GetInventory - GET /v2/store/inventory
+    /// UpdateUser - PUT /v2/user/{username}
-                async fn get_inventory(
+    async fn update_user(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<GetInventoryResponse, String>;
+        path_params: models::UpdateUserPathParams,
-
+        body: models::User,
-
+    ) -> Result<UpdateUserResponse, String>;
-                /// Find purchase order by ID.
-                ///
-                /// GetOrderById - GET /v2/store/order/{orderId}
-                async fn get_order_by_id(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  path_params: models::GetOrderByIdPathParams,
-                ) -> Result<GetOrderByIdResponse, String>;
-
-
-                /// Place an order for a pet.
-                ///
-                /// PlaceOrder - POST /v2/store/order
-                async fn place_order(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: models::Order,
-                ) -> Result<PlaceOrderResponse, String>;
-
-
-                /// Create user.
-                ///
-                /// CreateUser - POST /v2/user
-                async fn create_user(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: models::User,
-                ) -> Result<CreateUserResponse, String>;
-
-
-                /// Creates list of users with given input array.
-                ///
-                /// CreateUsersWithArrayInput - POST /v2/user/createWithArray
-                async fn create_users_with_array_input(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Vec<models::User>,
-                ) -> Result<CreateUsersWithArrayInputResponse, String>;
-
-
-                /// Creates list of users with given input array.
-                ///
-                /// CreateUsersWithListInput - POST /v2/user/createWithList
-                async fn create_users_with_list_input(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: Vec<models::User>,
-                ) -> Result<CreateUsersWithListInputResponse, String>;
-
-
-                /// Delete user.
-                ///
-                /// DeleteUser - DELETE /v2/user/{username}
-                async fn delete_user(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  path_params: models::DeleteUserPathParams,
-                ) -> Result<DeleteUserResponse, String>;
-
-
-                /// Get user by user name.
-                ///
-                /// GetUserByName - GET /v2/user/{username}
-                async fn get_user_by_name(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  path_params: models::GetUserByNamePathParams,
-                ) -> Result<GetUserByNameResponse, String>;
-
-
-                /// Logs user into the system.
-                ///
-                /// LoginUser - GET /v2/user/login
-                async fn login_user(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  query_params: models::LoginUserQueryParams,
-                ) -> Result<LoginUserResponse, String>;
-
-
-                /// Logs out current logged in user session.
-                ///
-                /// LogoutUser - GET /v2/user/logout
-                async fn logout_user(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                ) -> Result<LogoutUserResponse, String>;
-
-
-                /// Updated user.
-                ///
-                /// UpdateUser - PUT /v2/user/{username}
-                async fn update_user(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                  path_params: models::UpdateUserPathParams,
-                        body: models::User,
-                ) -> Result<UpdateUserResponse, String>;
-
 }
 
 #[cfg(feature = "server")]

samples/server/petstore/rust-axum/output/ping-bearer-auth/src/header.rs

@@ -30,11 +30,16 @@ macro_rules! ihv_generate {
                 match hdr_value.to_str() {
                     Ok(hdr_value) => match hdr_value.parse::<$t>() {
                         Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!("Unable to parse {} as a string: {}",
+                        Err(e) => Err(format!(
-                            stringify!($t), e)),
+                            "Unable to parse {} as a string: {}",
+                            stringify!($t),
+                            e
+                        )),
                     },
-                    Err(e) => Err(format!("Unable to parse header {:?} as a string - {}",
+                    Err(e) => Err(format!(
-                        hdr_value, e)),
+                        "Unable to parse header {:?} as a string - {}",
+                        hdr_value, e
+                    )),
                 }
             }
         }
@@ -69,14 +74,17 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(
                 hdr_value
-                .split(',')
+                    .split(',')
-                .filter_map(|x| match x.trim() {
+                    .filter_map(|x| match x.trim() {
-                    "" => None,
+                        "" => None,
-                    y => Some(y.to_string()),
+                        y => Some(y.to_string()),
-                })
+                    })
-                .collect())),
+                    .collect(),
-            Err(e) => Err(format!("Unable to parse header: {:?} as a string - {}",
+            )),
-                hdr_value, e)),
+            Err(e) => Err(format!(
+                "Unable to parse header: {:?} as a string - {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -85,11 +93,13 @@ impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
     type Error = String;
 
     fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-       match HeaderValue::from_str(&hdr_value.0.join(", ")) {
+        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-           Ok(hdr_value) => Ok(hdr_value),
+            Ok(hdr_value) => Ok(hdr_value),
-           Err(e) => Err(format!("Unable to convert {:?} into a header - {}",
+            Err(e) => Err(format!(
-               hdr_value, e))
+                "Unable to convert {:?} into a header - {}",
-       }
+                hdr_value, e
+            )),
+        }
     }
 }
 
@@ -101,8 +111,7 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
     fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}",
+            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-                hdr_value, e)),
         }
     }
 }
@@ -113,8 +122,10 @@ impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -128,11 +139,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match hdr_value.parse() {
                 Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}",
+                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -143,8 +155,10 @@ impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0.to_string()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert: {:?} into a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert: {:?} into a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -158,11 +172,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
                 Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}",
+                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert header {:?} to string {}",
+            Err(e) => Err(format!(
-                    hdr_value, e)),
+                "Unable to convert header {:?} to string {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -173,8 +188,10 @@ impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} to a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} to a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }

samples/server/petstore/rust-axum/output/ping-bearer-auth/src/lib.rs

@@ -1,4 +1,12 @@
-#![allow(missing_docs, trivial_casts, unused_variables, unused_mut, unused_imports, unused_extern_crates, non_camel_case_types)]
+#![allow(
+    missing_docs,
+    trivial_casts,
+    unused_variables,
+    unused_mut,
+    unused_imports,
+    unused_extern_crates,
+    non_camel_case_types
+)]
 #![allow(unused_imports, unused_attributes)]
 #![allow(clippy::derive_partial_eq_without_eq, clippy::disallowed_names)]
 
@@ -14,28 +22,25 @@ use types::*;
 pub const BASE_PATH: &str = "";
 pub const API_VERSION: &str = "1.0";
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum PingGetResponse {
     /// OK
-    Status201_OK
+    Status201_OK,
 }
 
-
 /// API
 #[async_trait]
 #[allow(clippy::ptr_arg)]
 pub trait Api {
-
+    /// PingGet - GET /ping
-                /// PingGet - GET /ping
+    async fn ping_get(
-                async fn ping_get(
+        &self,
-                &self,
+        method: Method,
-                method: Method,
+        host: Host,
-                host: Host,
+        cookies: CookieJar,
-                cookies: CookieJar,
+    ) -> Result<PingGetResponse, String>;
-                ) -> Result<PingGetResponse, String>;
-
 }
 
 #[cfg(feature = "server")]

samples/server/petstore/rust-axum/output/ping-bearer-auth/src/models.rs

@@ -6,6 +6,3 @@ use validator::Validate;
 #[cfg(feature = "server")]
 use crate::header;
 use crate::{models, types::*};
-
-      
-

samples/server/petstore/rust-axum/output/ping-bearer-auth/src/server/mod.rs

@@ -12,9 +12,7 @@ use crate::{header, types::*};
 #[allow(unused_imports)]
 use crate::models;
 
-use crate::{Api,
+use crate::{Api, PingGetResponse};
-     PingGetResponse
-};
 
 /// Setup API Server.
 pub fn new<I, A>(api_impl: I) -> Router
@@ -24,74 +22,59 @@ where
 {
     // build our application with a route
     Router::new()
-        .route("/ping",
+        .route("/ping", get(ping_get::<I, A>))
-            get(ping_get::<I, A>)
-        )
         .with_state(api_impl)
 }
 
-
 #[tracing::instrument(skip_all)]
-fn ping_get_validation(
+fn ping_get_validation() -> std::result::Result<(), ValidationErrors> {
-) -> std::result::Result<(
+    Ok(())
-), ValidationErrors>
-{
-
-Ok((
-))
 }
 
 /// PingGet - GET /ping
 #[tracing::instrument(skip_all)]
 async fn ping_get<I, A>(
-  method: Method,
+    method: Method,
-  host: Host,
+    host: Host,
-  cookies: CookieJar,
+    cookies: CookieJar,
- State(api_impl): State<I>,
+    State(api_impl): State<I>,
 ) -> Result<Response, StatusCode>
-where 
+where
     I: AsRef<A> + Send + Sync,
     A: Api,
 {
+    #[allow(clippy::redundant_closure)]
+    let validation = tokio::task::spawn_blocking(move || ping_get_validation())
+        .await
+        .unwrap();
 
-      #[allow(clippy::redundant_closure)]
+    let Ok(()) = validation else {
-      let validation = tokio::task::spawn_blocking(move || 
+        return Response::builder()
-    ping_get_validation(
-    )
-  ).await.unwrap();
-
-  let Ok((
-  )) = validation else {
-    return Response::builder()
             .status(StatusCode::BAD_REQUEST)
             .body(Body::from(validation.unwrap_err().to_string()))
-            .map_err(|_| StatusCode::BAD_REQUEST); 
+            .map_err(|_| StatusCode::BAD_REQUEST);
-  };
+    };
 
-  let result = api_impl.as_ref().ping_get(
+    let result = api_impl.as_ref().ping_get(method, host, cookies).await;
-      method,
-      host,
-      cookies,
-  ).await;
 
-  let mut response = Response::builder();
+    let mut response = Response::builder();
 
-  let resp = match result {
+    let resp = match result {
-                                            Ok(rsp) => match rsp {
+        Ok(rsp) => match rsp {
-                                                PingGetResponse::Status201_OK
+            PingGetResponse::Status201_OK => {
-                                                => {
+                let mut response = response.status(201);
+                response.body(Body::empty())
+            }
+        },
+        Err(_) => {
+            // Application code returned an error. This should not happen, as the implementation should
+            // return a valid response.
+            response.status(500).body(Body::empty())
+        }
+    };
 
-                                                  let mut response = response.status(201);
+    resp.map_err(|e| {
-                                                  response.body(Body::empty())
+        error!(error = ?e);
-                                                },
+        StatusCode::INTERNAL_SERVER_ERROR
-                                            },
+    })
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                response.status(500).body(Body::empty())
-                                            },
-                                        };
-
-                                        resp.map_err(|e| { error!(error = ?e); StatusCode::INTERNAL_SERVER_ERROR })
 }
-

samples/server/petstore/rust-axum/output/rust-axum-test/src/header.rs

@@ -30,11 +30,16 @@ macro_rules! ihv_generate {
                 match hdr_value.to_str() {
                     Ok(hdr_value) => match hdr_value.parse::<$t>() {
                         Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!("Unable to parse {} as a string: {}",
+                        Err(e) => Err(format!(
-                            stringify!($t), e)),
+                            "Unable to parse {} as a string: {}",
+                            stringify!($t),
+                            e
+                        )),
                     },
-                    Err(e) => Err(format!("Unable to parse header {:?} as a string - {}",
+                    Err(e) => Err(format!(
-                        hdr_value, e)),
+                        "Unable to parse header {:?} as a string - {}",
+                        hdr_value, e
+                    )),
                 }
             }
         }
@@ -69,14 +74,17 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(
                 hdr_value
-                .split(',')
+                    .split(',')
-                .filter_map(|x| match x.trim() {
+                    .filter_map(|x| match x.trim() {
-                    "" => None,
+                        "" => None,
-                    y => Some(y.to_string()),
+                        y => Some(y.to_string()),
-                })
+                    })
-                .collect())),
+                    .collect(),
-            Err(e) => Err(format!("Unable to parse header: {:?} as a string - {}",
+            )),
-                hdr_value, e)),
+            Err(e) => Err(format!(
+                "Unable to parse header: {:?} as a string - {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -85,11 +93,13 @@ impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
     type Error = String;
 
     fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-       match HeaderValue::from_str(&hdr_value.0.join(", ")) {
+        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-           Ok(hdr_value) => Ok(hdr_value),
+            Ok(hdr_value) => Ok(hdr_value),
-           Err(e) => Err(format!("Unable to convert {:?} into a header - {}",
+            Err(e) => Err(format!(
-               hdr_value, e))
+                "Unable to convert {:?} into a header - {}",
-       }
+                hdr_value, e
+            )),
+        }
     }
 }
 
@@ -101,8 +111,7 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
     fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
         match hdr_value.to_str() {
             Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}",
+            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-                hdr_value, e)),
         }
     }
 }
@@ -113,8 +122,10 @@ impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -128,11 +139,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match hdr_value.parse() {
                 Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}",
+                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert {:?} from a header {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} from a header {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -143,8 +155,10 @@ impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(&hdr_value.0.to_string()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert: {:?} into a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e))
+                "Unable to convert: {:?} into a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -158,11 +172,12 @@ impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
         match hdr_value.to_str() {
             Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
                 Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}",
+                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-                    hdr_value, e)),
             },
-            Err(e) => Err(format!("Unable to convert header {:?} to string {}",
+            Err(e) => Err(format!(
-                    hdr_value, e)),
+                "Unable to convert header {:?} to string {}",
+                hdr_value, e
+            )),
         }
     }
 }
@@ -173,8 +188,10 @@ impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
     fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
         match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
             Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!("Unable to convert {:?} to a header: {}",
+            Err(e) => Err(format!(
-                hdr_value, e)),
+                "Unable to convert {:?} to a header: {}",
+                hdr_value, e
+            )),
         }
     }
 }

samples/server/petstore/rust-axum/output/rust-axum-test/src/lib.rs

@@ -1,4 +1,12 @@
-#![allow(missing_docs, trivial_casts, unused_variables, unused_mut, unused_imports, unused_extern_crates, non_camel_case_types)]
+#![allow(
+    missing_docs,
+    trivial_casts,
+    unused_variables,
+    unused_mut,
+    unused_imports,
+    unused_extern_crates,
+    non_camel_case_types
+)]
 #![allow(unused_imports, unused_attributes)]
 #![allow(clippy::derive_partial_eq_without_eq, clippy::disallowed_names)]
 
@@ -14,183 +22,167 @@ use types::*;
 pub const BASE_PATH: &str = "";
 pub const API_VERSION: &str = "2.3.4";
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum AllOfGetResponse {
     /// OK
-    Status200_OK
+    Status200_OK(models::AllOfObject),
-    (models::AllOfObject)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum DummyGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum DummyPutResponse {
     /// Success
-    Status200_Success
+    Status200_Success,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum FileResponseGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success(ByteArray),
-    (ByteArray)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum GetStructuredYamlResponse {
     /// OK
-    Status200_OK
+    Status200_OK(String),
-    (String)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum HtmlPostResponse {
     /// Success
-    Status200_Success
+    Status200_Success(String),
-    (String)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum PostYamlResponse {
     /// OK
-    Status204_OK
+    Status204_OK,
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum RawJsonGetResponse {
     /// Success
-    Status200_Success
+    Status200_Success(crate::types::Object),
-    (crate::types::Object)
 }
 
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
 pub enum SoloObjectPostResponse {
     /// OK
-    Status204_OK
+    Status204_OK,
 }
 
-
 /// API
 #[async_trait]
 #[allow(clippy::ptr_arg)]
 pub trait Api {
+    /// AllOfGet - GET /allOf
+    async fn all_of_get(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<AllOfGetResponse, String>;
 
-                /// AllOfGet - GET /allOf
+    /// A dummy endpoint to make the spec valid..
-                async fn all_of_get(
+    ///
-                &self,
+    /// DummyGet - GET /dummy
-                method: Method,
+    async fn dummy_get(
-                host: Host,
+        &self,
-                cookies: CookieJar,
+        method: Method,
-                ) -> Result<AllOfGetResponse, String>;
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<DummyGetResponse, String>;
 
+    /// DummyPut - PUT /dummy
+    async fn dummy_put(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: models::DummyPutRequest,
+    ) -> Result<DummyPutResponse, String>;
 
-                /// A dummy endpoint to make the spec valid..
+    /// Get a file.
-                ///
+    ///
-                /// DummyGet - GET /dummy
+    /// FileResponseGet - GET /file_response
-                async fn dummy_get(
+    async fn file_response_get(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<DummyGetResponse, String>;
+    ) -> Result<FileResponseGetResponse, String>;
 
+    /// GetStructuredYaml - GET /get-structured-yaml
+    async fn get_structured_yaml(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+    ) -> Result<GetStructuredYamlResponse, String>;
 
-                /// DummyPut - PUT /dummy
+    /// Test HTML handling.
-                async fn dummy_put(
+    ///
-                &self,
+    /// HtmlPost - POST /html
-                method: Method,
+    async fn html_post(
-                host: Host,
+        &self,
-                cookies: CookieJar,
+        method: Method,
-                        body: models::DummyPutRequest,
+        host: Host,
-                ) -> Result<DummyPutResponse, String>;
+        cookies: CookieJar,
+        body: String,
+    ) -> Result<HtmlPostResponse, String>;
 
+    /// PostYaml - POST /post-yaml
+    async fn post_yaml(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: String,
+    ) -> Result<PostYamlResponse, String>;
 
-                /// Get a file.
+    /// Get an arbitrary JSON blob..
-                ///
+    ///
-                /// FileResponseGet - GET /file_response
+    /// RawJsonGet - GET /raw_json
-                async fn file_response_get(
+    async fn raw_json_get(
-                &self,
+        &self,
-                method: Method,
+        method: Method,
-                host: Host,
+        host: Host,
-                cookies: CookieJar,
+        cookies: CookieJar,
-                ) -> Result<FileResponseGetResponse, String>;
+    ) -> Result<RawJsonGetResponse, String>;
-
-
-                /// GetStructuredYaml - GET /get-structured-yaml
-                async fn get_structured_yaml(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                ) -> Result<GetStructuredYamlResponse, String>;
-
-
-                /// Test HTML handling.
-                ///
-                /// HtmlPost - POST /html
-                async fn html_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: String,
-                ) -> Result<HtmlPostResponse, String>;
-
-
-                /// PostYaml - POST /post-yaml
-                async fn post_yaml(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: String,
-                ) -> Result<PostYamlResponse, String>;
-
-
-                /// Get an arbitrary JSON blob..
-                ///
-                /// RawJsonGet - GET /raw_json
-                async fn raw_json_get(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                ) -> Result<RawJsonGetResponse, String>;
-
-
-                /// Send an arbitrary JSON blob.
-                ///
-                /// SoloObjectPost - POST /solo-object
-                async fn solo_object_post(
-                &self,
-                method: Method,
-                host: Host,
-                cookies: CookieJar,
-                        body: crate::types::Object,
-                ) -> Result<SoloObjectPostResponse, String>;
 
+    /// Send an arbitrary JSON blob.
+    ///
+    /// SoloObjectPost - POST /solo-object
+    async fn solo_object_post(
+        &self,
+        method: Method,
+        host: Host,
+        cookies: CookieJar,
+        body: crate::types::Object,
+    ) -> Result<SoloObjectPostResponse, String>;
 }
 
 #[cfg(feature = "server")]

samples/server/petstore/rust-axum/output/rust-axum-test/src/models.rs

@@ -7,38 +7,22 @@ use validator::Validate;
 use crate::header;
 use crate::{models, types::*};
 
-      
-      
-      
-      
-      
-      
-      
-      
-      
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct ANullableContainer {
     #[serde(rename = "NullableThing")]
     #[serde(deserialize_with = "deserialize_optional_nullable")]
     #[serde(default = "default_optional_nullable")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub nullable_thing: Option<Nullable<String>>,
 
     #[serde(rename = "RequiredNullableThing")]
     pub required_nullable_thing: Nullable<String>,
-
 }
 
-
 impl ANullableContainer {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
-    pub fn new(required_nullable_thing: Nullable<String>, ) -> ANullableContainer {
+    pub fn new(required_nullable_thing: Nullable<String>) -> ANullableContainer {
         ANullableContainer {
             nullable_thing: None,
             required_nullable_thing,
@@ -52,18 +36,21 @@ impl ANullableContainer {
 impl std::string::ToString for ANullableContainer {
     fn to_string(&self) -> String {
         let params: Vec<Option<String>> = vec![
-
             self.nullable_thing.as_ref().map(|nullable_thing| {
                 [
                     "NullableThing".to_string(),
-                    nullable_thing.as_ref().map_or("null".to_string(), |x| x.to_string()),
+                    nullable_thing
-                ].join(",")
+                        .as_ref()
+                        .map_or("null".to_string(), |x| x.to_string()),
+                ]
+                .join(",")
             }),
-
-
             Some("RequiredNullableThing".to_string()),
-            Some(self.required_nullable_thing.as_ref().map_or("null".to_string(), |x| x.to_string())),
+            Some(
-
+                self.required_nullable_thing
+                    .as_ref()
+                    .map_or("null".to_string(), |x| x.to_string()),
+            ),
         ];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
@@ -94,7 +81,11 @@ impl std::str::FromStr for ANullableContainer {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing ANullableContainer".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing ANullableContainer".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
@@ -112,8 +103,12 @@ impl std::str::FromStr for ANullableContainer {
 
         // Use the intermediate representation to return the struct
         std::result::Result::Ok(ANullableContainer {
-            nullable_thing: std::result::Result::Err("Nullable types not supported in ANullableContainer".to_string())?,
+            nullable_thing: std::result::Result::Err(
-            required_nullable_thing: std::result::Result::Err("Nullable types not supported in ANullableContainer".to_string())?,
+                "Nullable types not supported in ANullableContainer".to_string(),
+            )?,
+            required_nullable_thing: std::result::Result::Err(
+                "Nullable types not supported in ANullableContainer".to_string(),
+            )?,
         })
     }
 }
@@ -124,13 +119,16 @@ impl std::str::FromStr for ANullableContainer {
 impl std::convert::TryFrom<header::IntoHeaderValue<ANullableContainer>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<ANullableContainer>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<ANullableContainer>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for ANullableContainer - value: {} is invalid {}",
+                "Invalid header value for ANullableContainer - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -141,24 +139,25 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<ANullableCon
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <ANullableContainer as std::str::FromStr>::from_str(value) {
+                match <ANullableContainer as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into ANullableContainer - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into ANullableContainer - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
 /// An additionalPropertiesObject
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
@@ -212,28 +211,24 @@ impl ::std::str::FromStr for AdditionalPropertiesObject {
     type Err = &'static str;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        std::result::Result::Err("Parsing additionalProperties for AdditionalPropertiesObject is not supported")
+        std::result::Result::Err(
+            "Parsing additionalProperties for AdditionalPropertiesObject is not supported",
+        )
     }
 }
 
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct AllOfObject {
     #[serde(rename = "sampleProperty")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub sample_property: Option<String>,
 
     #[serde(rename = "sampleBaseProperty")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub sample_base_property: Option<String>,
-
 }
 
-
 impl AllOfObject {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
     pub fn new() -> AllOfObject {
@@ -250,22 +245,18 @@ impl AllOfObject {
 impl std::string::ToString for AllOfObject {
     fn to_string(&self) -> String {
         let params: Vec<Option<String>> = vec![
-
             self.sample_property.as_ref().map(|sample_property| {
-                [
+                ["sampleProperty".to_string(), sample_property.to_string()].join(",")
-                    "sampleProperty".to_string(),
-                    sample_property.to_string(),
-                ].join(",")
             }),
-
+            self.sample_base_property
-
+                .as_ref()
-            self.sample_base_property.as_ref().map(|sample_base_property| {
+                .map(|sample_base_property| {
-                [
+                    [
-                    "sampleBaseProperty".to_string(),
+                        "sampleBaseProperty".to_string(),
-                    sample_base_property.to_string(),
+                        sample_base_property.to_string(),
-                ].join(",")
+                    ]
-            }),
+                    .join(",")
-
+                }),
         ];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
@@ -296,17 +287,29 @@ impl std::str::FromStr for AllOfObject {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing AllOfObject".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing AllOfObject".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
                 #[allow(clippy::match_single_binding)]
                 match key {
                     #[allow(clippy::redundant_clone)]
-                    "sampleProperty" => intermediate_rep.sample_property.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "sampleProperty" => intermediate_rep.sample_property.push(
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
                     #[allow(clippy::redundant_clone)]
-                    "sampleBaseProperty" => intermediate_rep.sample_base_property.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "sampleBaseProperty" => intermediate_rep.sample_base_property.push(
-                    _ => return std::result::Result::Err("Unexpected key while parsing AllOfObject".to_string())
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing AllOfObject".to_string(),
+                        )
+                    }
                 }
             }
 
@@ -328,13 +331,16 @@ impl std::str::FromStr for AllOfObject {
 impl std::convert::TryFrom<header::IntoHeaderValue<AllOfObject>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<AllOfObject>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<AllOfObject>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for AllOfObject - value: {} is invalid {}",
+                "Invalid header value for AllOfObject - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -345,37 +351,33 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<AllOfObject>
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <AllOfObject as std::str::FromStr>::from_str(value) {
+                match <AllOfObject as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into AllOfObject - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into AllOfObject - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct BaseAllOf {
     #[serde(rename = "sampleBaseProperty")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub sample_base_property: Option<String>,
-
 }
 
-
 impl BaseAllOf {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
     pub fn new() -> BaseAllOf {
@@ -390,16 +392,17 @@ impl BaseAllOf {
 /// Should be implemented in a serde serializer
 impl std::string::ToString for BaseAllOf {
     fn to_string(&self) -> String {
-        let params: Vec<Option<String>> = vec![
+        let params: Vec<Option<String>> =
-
+            vec![self
-            self.sample_base_property.as_ref().map(|sample_base_property| {
+                .sample_base_property
-                [
+                .as_ref()
-                    "sampleBaseProperty".to_string(),
+                .map(|sample_base_property| {
-                    sample_base_property.to_string(),
+                    [
-                ].join(",")
+                        "sampleBaseProperty".to_string(),
-            }),
+                        sample_base_property.to_string(),
-
+                    ]
-        ];
+                    .join(",")
+                })];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
     }
@@ -428,15 +431,25 @@ impl std::str::FromStr for BaseAllOf {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing BaseAllOf".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing BaseAllOf".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
                 #[allow(clippy::match_single_binding)]
                 match key {
                     #[allow(clippy::redundant_clone)]
-                    "sampleBaseProperty" => intermediate_rep.sample_base_property.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "sampleBaseProperty" => intermediate_rep.sample_base_property.push(
-                    _ => return std::result::Result::Err("Unexpected key while parsing BaseAllOf".to_string())
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing BaseAllOf".to_string(),
+                        )
+                    }
                 }
             }
 
@@ -457,13 +470,16 @@ impl std::str::FromStr for BaseAllOf {
 impl std::convert::TryFrom<header::IntoHeaderValue<BaseAllOf>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<BaseAllOf>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<BaseAllOf>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for BaseAllOf - value: {} is invalid {}",
+                "Invalid header value for BaseAllOf - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -474,27 +490,25 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<BaseAllOf> {
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <BaseAllOf as std::str::FromStr>::from_str(value) {
+                match <BaseAllOf as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into BaseAllOf - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into BaseAllOf - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct DummyPutRequest {
@@ -502,19 +516,14 @@ pub struct DummyPutRequest {
     pub id: String,
 
     #[serde(rename = "password")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub password: Option<String>,
-
 }
 
-
 impl DummyPutRequest {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
-    pub fn new(id: String, ) -> DummyPutRequest {
+    pub fn new(id: String) -> DummyPutRequest {
-        DummyPutRequest {
+        DummyPutRequest { id, password: None }
-            id,
-            password: None,
-        }
     }
 }
 
@@ -524,18 +533,11 @@ impl DummyPutRequest {
 impl std::string::ToString for DummyPutRequest {
     fn to_string(&self) -> String {
         let params: Vec<Option<String>> = vec![
-
             Some("id".to_string()),
             Some(self.id.to_string()),
-
+            self.password
-
+                .as_ref()
-            self.password.as_ref().map(|password| {
+                .map(|password| ["password".to_string(), password.to_string()].join(",")),
-                [
-                    "password".to_string(),
-                    password.to_string(),
-                ].join(",")
-            }),
-
         ];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
@@ -566,17 +568,29 @@ impl std::str::FromStr for DummyPutRequest {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing DummyPutRequest".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing DummyPutRequest".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
                 #[allow(clippy::match_single_binding)]
                 match key {
                     #[allow(clippy::redundant_clone)]
-                    "id" => intermediate_rep.id.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "id" => intermediate_rep.id.push(
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
                     #[allow(clippy::redundant_clone)]
-                    "password" => intermediate_rep.password.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "password" => intermediate_rep.password.push(
-                    _ => return std::result::Result::Err("Unexpected key while parsing DummyPutRequest".to_string())
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing DummyPutRequest".to_string(),
+                        )
+                    }
                 }
             }
 
@@ -586,7 +600,11 @@ impl std::str::FromStr for DummyPutRequest {
 
         // Use the intermediate representation to return the struct
         std::result::Result::Ok(DummyPutRequest {
-            id: intermediate_rep.id.into_iter().next().ok_or_else(|| "id missing in DummyPutRequest".to_string())?,
+            id: intermediate_rep
+                .id
+                .into_iter()
+                .next()
+                .ok_or_else(|| "id missing in DummyPutRequest".to_string())?,
             password: intermediate_rep.password.into_iter().next(),
         })
     }
@@ -598,13 +616,16 @@ impl std::str::FromStr for DummyPutRequest {
 impl std::convert::TryFrom<header::IntoHeaderValue<DummyPutRequest>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<DummyPutRequest>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<DummyPutRequest>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for DummyPutRequest - value: {} is invalid {}",
+                "Invalid header value for DummyPutRequest - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -615,45 +636,40 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<DummyPutRequ
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <DummyPutRequest as std::str::FromStr>::from_str(value) {
+                match <DummyPutRequest as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into DummyPutRequest - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into DummyPutRequest - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
 /// structured response
 
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct GetYamlResponse {
-/// Inner string
+    /// Inner string
     #[serde(rename = "value")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub value: Option<String>,
-
 }
 
-
 impl GetYamlResponse {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
     pub fn new() -> GetYamlResponse {
-        GetYamlResponse {
+        GetYamlResponse { value: None }
-            value: None,
-        }
     }
 }
 
@@ -662,16 +678,10 @@ impl GetYamlResponse {
 /// Should be implemented in a serde serializer
 impl std::string::ToString for GetYamlResponse {
     fn to_string(&self) -> String {
-        let params: Vec<Option<String>> = vec![
+        let params: Vec<Option<String>> = vec![self
-
+            .value
-            self.value.as_ref().map(|value| {
+            .as_ref()
-                [
+            .map(|value| ["value".to_string(), value.to_string()].join(","))];
-                    "value".to_string(),
-                    value.to_string(),
-                ].join(",")
-            }),
-
-        ];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
     }
@@ -700,15 +710,25 @@ impl std::str::FromStr for GetYamlResponse {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing GetYamlResponse".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing GetYamlResponse".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
                 #[allow(clippy::match_single_binding)]
                 match key {
                     #[allow(clippy::redundant_clone)]
-                    "value" => intermediate_rep.value.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "value" => intermediate_rep.value.push(
-                    _ => return std::result::Result::Err("Unexpected key while parsing GetYamlResponse".to_string())
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing GetYamlResponse".to_string(),
+                        )
+                    }
                 }
             }
 
@@ -729,13 +749,16 @@ impl std::str::FromStr for GetYamlResponse {
 impl std::convert::TryFrom<header::IntoHeaderValue<GetYamlResponse>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<GetYamlResponse>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<GetYamlResponse>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for GetYamlResponse - value: {} is invalid {}",
+                "Invalid header value for GetYamlResponse - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -746,44 +769,39 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<GetYamlRespo
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <GetYamlResponse as std::str::FromStr>::from_str(value) {
+                match <GetYamlResponse as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into GetYamlResponse - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into GetYamlResponse - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
 /// An object of objects
 
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct ObjectOfObjects {
     #[serde(rename = "inner")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub inner: Option<models::ObjectOfObjectsInner>,
-
 }
 
-
 impl ObjectOfObjects {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
     pub fn new() -> ObjectOfObjects {
-        ObjectOfObjects {
+        ObjectOfObjects { inner: None }
-            inner: None,
-        }
     }
 }
 
@@ -824,15 +842,26 @@ impl std::str::FromStr for ObjectOfObjects {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing ObjectOfObjects".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing ObjectOfObjects".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
                 #[allow(clippy::match_single_binding)]
                 match key {
                     #[allow(clippy::redundant_clone)]
-                    "inner" => intermediate_rep.inner.push(<models::ObjectOfObjectsInner as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "inner" => intermediate_rep.inner.push(
-                    _ => return std::result::Result::Err("Unexpected key while parsing ObjectOfObjects".to_string())
+                        <models::ObjectOfObjectsInner as std::str::FromStr>::from_str(val)
+                            .map_err(|x| x.to_string())?,
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing ObjectOfObjects".to_string(),
+                        )
+                    }
                 }
             }
 
@@ -853,13 +882,16 @@ impl std::str::FromStr for ObjectOfObjects {
 impl std::convert::TryFrom<header::IntoHeaderValue<ObjectOfObjects>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<ObjectOfObjects>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<ObjectOfObjects>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for ObjectOfObjects - value: {} is invalid {}",
+                "Invalid header value for ObjectOfObjects - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -870,27 +902,25 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<ObjectOfObje
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <ObjectOfObjects as std::str::FromStr>::from_str(value) {
+                match <ObjectOfObjects as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into ObjectOfObjects - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into ObjectOfObjects - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
 
-
-
-
-
-
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
 #[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
 pub struct ObjectOfObjectsInner {
@@ -898,15 +928,13 @@ pub struct ObjectOfObjectsInner {
     pub required_thing: String,
 
     #[serde(rename = "optional_thing")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub optional_thing: Option<i32>,
-
 }
 
-
 impl ObjectOfObjectsInner {
     #[allow(clippy::new_without_default, clippy::too_many_arguments)]
-    pub fn new(required_thing: String, ) -> ObjectOfObjectsInner {
+    pub fn new(required_thing: String) -> ObjectOfObjectsInner {
         ObjectOfObjectsInner {
             required_thing,
             optional_thing: None,
@@ -920,18 +948,11 @@ impl ObjectOfObjectsInner {
 impl std::string::ToString for ObjectOfObjectsInner {
     fn to_string(&self) -> String {
         let params: Vec<Option<String>> = vec![
-
             Some("required_thing".to_string()),
             Some(self.required_thing.to_string()),
-
-
             self.optional_thing.as_ref().map(|optional_thing| {
-                [
+                ["optional_thing".to_string(), optional_thing.to_string()].join(",")
-                    "optional_thing".to_string(),
-                    optional_thing.to_string(),
-                ].join(",")
             }),
-
         ];
 
         params.into_iter().flatten().collect::<Vec<_>>().join(",")
@@ -962,17 +983,29 @@ impl std::str::FromStr for ObjectOfObjectsInner {
         while key_result.is_some() {
             let val = match string_iter.next() {
                 Some(x) => x,
-                None => return std::result::Result::Err("Missing value while parsing ObjectOfObjectsInner".to_string())
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing ObjectOfObjectsInner".to_string(),
+                    )
+                }
             };
 
             if let Some(key) = key_result {
                 #[allow(clippy::match_single_binding)]
                 match key {
                     #[allow(clippy::redundant_clone)]
-                    "required_thing" => intermediate_rep.required_thing.push(<String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "required_thing" => intermediate_rep.required_thing.push(
+                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
                     #[allow(clippy::redundant_clone)]
-                    "optional_thing" => intermediate_rep.optional_thing.push(<i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?),
+                    "optional_thing" => intermediate_rep.optional_thing.push(
-                    _ => return std::result::Result::Err("Unexpected key while parsing ObjectOfObjectsInner".to_string())
+                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing ObjectOfObjectsInner".to_string(),
+                        )
+                    }
                 }
             }
 
@@ -982,7 +1015,11 @@ impl std::str::FromStr for ObjectOfObjectsInner {
 
         // Use the intermediate representation to return the struct
         std::result::Result::Ok(ObjectOfObjectsInner {
-            required_thing: intermediate_rep.required_thing.into_iter().next().ok_or_else(|| "required_thing missing in ObjectOfObjectsInner".to_string())?,
+            required_thing: intermediate_rep
+                .required_thing
+                .into_iter()
+                .next()
+                .ok_or_else(|| "required_thing missing in ObjectOfObjectsInner".to_string())?,
             optional_thing: intermediate_rep.optional_thing.into_iter().next(),
         })
     }
@@ -994,13 +1031,16 @@ impl std::str::FromStr for ObjectOfObjectsInner {
 impl std::convert::TryFrom<header::IntoHeaderValue<ObjectOfObjectsInner>> for HeaderValue {
     type Error = String;
 
-    fn try_from(hdr_value: header::IntoHeaderValue<ObjectOfObjectsInner>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<ObjectOfObjectsInner>,
+    ) -> std::result::Result<Self, Self::Error> {
         let hdr_value = hdr_value.to_string();
         match HeaderValue::from_str(&hdr_value) {
-             std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-             std::result::Result::Err(e) => std::result::Result::Err(
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                 format!("Invalid header value for ObjectOfObjectsInner - value: {} is invalid {}",
+                "Invalid header value for ObjectOfObjectsInner - value: {} is invalid {}",
-                     hdr_value, e))
+                hdr_value, e
+            )),
         }
     }
 }
@@ -1011,20 +1051,21 @@ impl std::convert::TryFrom<HeaderValue> for header::IntoHeaderValue<ObjectOfObje
 
     fn try_from(hdr_value: HeaderValue) -> std::result::Result<Self, Self::Error> {
         match hdr_value.to_str() {
-             std::result::Result::Ok(value) => {
+            std::result::Result::Ok(value) => {
-                    match <ObjectOfObjectsInner as std::str::FromStr>::from_str(value) {
+                match <ObjectOfObjectsInner as std::str::FromStr>::from_str(value) {
-                        std::result::Result::Ok(value) => std::result::Result::Ok(header::IntoHeaderValue(value)),
+                    std::result::Result::Ok(value) => {
-                        std::result::Result::Err(err) => std::result::Result::Err(
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                            format!("Unable to convert header value '{}' into ObjectOfObjectsInner - {}",
-                                value, err))
                     }
-             },
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-             std::result::Result::Err(e) => std::result::Result::Err(
+                        "Unable to convert header value '{}' into ObjectOfObjectsInner - {}",
-                 format!("Unable to convert header: {:?} to string: {}",
+                        value, err
-                     hdr_value, e))
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
         }
     }
 }
-
-
-