[Rust][Client] Unify sync/async client structure (#6753)

* Unify sync/async client structure (configuration as first param instead of a struct).

* Fix: Hyper client requires the client.rs file.

Co-authored-by: Henning Holm <git@henningholm.de>

* Add API method comments (description and/or notes when available).

Co-authored-by: Henning Holm <git@henningholm.de>

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

@@ -300,8 +300,6 @@ public class RustClientCodegen extends DefaultCodegen implements CodegenConfig {
         supportingFiles.add(new SupportingFile(getLibrary() + "/configuration.mustache", apiFolder, "configuration.rs"));
         if (HYPER_LIBRARY.equals(getLibrary())) {
             supportingFiles.add(new SupportingFile("request.rs", apiFolder, "request.rs"));
-        }
-        if (!getSupportAsync()) { // for sync only
             supportingFiles.add(new SupportingFile(getLibrary() + "/client.mustache", apiFolder, "client.rs"));
         }
     }

modules/openapi-generator/src/main/resources/rust/reqwest/api.mustache

@@ -1,28 +1,10 @@
 {{>partial_header}}
-#[allow(unused_imports)]
-use std::rc::Rc;
-{{^supportAsync}}use std::borrow::Borrow;{{/supportAsync}}
-use std::option::Option;
 
 use reqwest;
 
 use crate::apis::ResponseContent;
 use super::{Error, configuration};
 
-{{^supportAsync}}
-pub struct {{{classname}}}Client {
-    configuration: Rc<configuration::Configuration>,
-}
-
-impl {{{classname}}}Client {
-    pub fn new(configuration: Rc<configuration::Configuration>) -> {{{classname}}}Client {
-        {{{classname}}}Client {
-            configuration,
-        }
-    }
-}
-
-{{/supportAsync}}
 {{#operations}}
 {{#operation}}
 {{#vendorExtensions.x-group-parameters}}
@@ -89,253 +71,238 @@ pub enum {{{operationIdCamelCase}}}Error {
 {{/operation}}
 {{/operations}}
 
-{{^supportAsync}}
-pub trait {{{classname}}} {
 {{#operations}}
 {{#operation}}
-    {{#vendorExtensions.x-group-parameters}}
-    fn {{{operationId}}}(&self{{#allParams}}{{#-first}}, params: {{{operationIdCamelCase}}}Params{{/-first}}{{/allParams}}) -> Result<{{#supportMultipleResponses}}ResponseContent<{{{operationIdCamelCase}}}Success>{{/supportMultipleResponses}}{{^supportMultipleResponses}}{{^returnType}}(){{/returnType}}{{#returnType}}{{{returnType}}}{{/returnType}}{{/supportMultipleResponses}}, Error<{{{operationIdCamelCase}}}Error>>;
-    {{/vendorExtensions.x-group-parameters}}
-    {{^vendorExtensions.x-group-parameters}}
-    fn {{{operationId}}}(&self, {{#allParams}}{{{paramName}}}: {{^required}}Option<{{/required}}{{#required}}{{#isNullable}}Option<{{/isNullable}}{{/required}}{{#isString}}&str{{/isString}}{{#isUuid}}&str{{/isUuid}}{{^isString}}{{^isUuid}}{{^isPrimitiveType}}{{^isContainer}}crate::models::{{/isContainer}}{{/isPrimitiveType}}{{{dataType}}}{{/isUuid}}{{/isString}}{{^required}}>{{/required}}{{#required}}{{#isNullable}}>{{/isNullable}}{{/required}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) -> Result<{{#supportMultipleResponses}}ResponseContent<{{{operationIdCamelCase}}}Success>{{/supportMultipleResponses}}{{^supportMultipleResponses}}{{^returnType}}(){{/returnType}}{{#returnType}}{{{returnType}}}{{/returnType}}{{/supportMultipleResponses}}, Error<{{{operationIdCamelCase}}}Error>>;
-    {{/vendorExtensions.x-group-parameters}}
-{{/operation}}
-{{/operations}}
-}
+{{#description}}
+/// {{{.}}}
+{{/description}}
+{{#notes}}
+/// {{{.}}}
+{{/notes}}
+{{#vendorExtensions.x-group-parameters}}
+pub {{#supportAsync}}async {{/supportAsync}}fn {{{operationId}}}(configuration: &configuration::Configuration{{#allParams}}{{#-first}}, params: {{{operationIdCamelCase}}}Params{{/-first}}{{/allParams}}) -> Result<{{#supportMultipleResponses}}ResponseContent<{{{operationIdCamelCase}}}Success>{{/supportMultipleResponses}}{{^supportMultipleResponses}}{{^returnType}}(){{/returnType}}{{#returnType}}{{{returnType}}}{{/returnType}}{{/supportMultipleResponses}}, Error<{{{operationIdCamelCase}}}Error>> {
+    // unbox the parameters
+    {{#allParams}}
+    let {{paramName}} = params.{{paramName}};
+    {{/allParams}}
 
-impl {{{classname}}} for {{{classname}}}Client {
-{{/supportAsync}}
-{{#operations}}
-{{#operation}}
-    {{#vendorExtensions.x-group-parameters}}
-    {{#supportAsync}}pub async {{/supportAsync}}fn {{{operationId}}}({{^supportAsync}}&self{{/supportAsync}}{{#supportAsync}}configuration: &configuration::Configuration{{/supportAsync}}{{#allParams}}{{#-first}}, params: {{{operationIdCamelCase}}}Params{{/-first}}{{/allParams}}) -> Result<{{#supportMultipleResponses}}ResponseContent<{{{operationIdCamelCase}}}Success>{{/supportMultipleResponses}}{{^supportMultipleResponses}}{{^returnType}}(){{/returnType}}{{#returnType}}{{{returnType}}}{{/returnType}}{{/supportMultipleResponses}}, Error<{{{operationIdCamelCase}}}Error>> {
-        // unbox the parameters
-        {{#allParams}}
-        let {{paramName}} = params.{{paramName}};
-        {{/allParams}}
+{{/vendorExtensions.x-group-parameters}}
+{{^vendorExtensions.x-group-parameters}}
+pub {{#supportAsync}}async {{/supportAsync}}fn {{{operationId}}}(configuration: &configuration::Configuration, {{#allParams}}{{{paramName}}}: {{^required}}Option<{{/required}}{{#required}}{{#isNullable}}Option<{{/isNullable}}{{/required}}{{#isString}}&str{{/isString}}{{#isUuid}}&str{{/isUuid}}{{^isString}}{{^isUuid}}{{^isPrimitiveType}}{{^isContainer}}crate::models::{{/isContainer}}{{/isPrimitiveType}}{{{dataType}}}{{/isUuid}}{{/isString}}{{^required}}>{{/required}}{{#required}}{{#isNullable}}>{{/isNullable}}{{/required}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) -> Result<{{#supportMultipleResponses}}ResponseContent<{{{operationIdCamelCase}}}Success>{{/supportMultipleResponses}}{{^supportMultipleResponses}}{{^returnType}}(){{/returnType}}{{#returnType}}{{{returnType}}}{{/returnType}}{{/supportMultipleResponses}}, Error<{{{operationIdCamelCase}}}Error>> {
+{{/vendorExtensions.x-group-parameters}}
 
-    {{/vendorExtensions.x-group-parameters}}
-    {{^vendorExtensions.x-group-parameters}}
-    {{#supportAsync}}pub async {{/supportAsync}}fn {{{operationId}}}({{^supportAsync}}&self{{/supportAsync}}{{#supportAsync}}configuration: &configuration::Configuration{{/supportAsync}}, {{#allParams}}{{{paramName}}}: {{^required}}Option<{{/required}}{{#required}}{{#isNullable}}Option<{{/isNullable}}{{/required}}{{#isString}}&str{{/isString}}{{#isUuid}}&str{{/isUuid}}{{^isString}}{{^isUuid}}{{^isPrimitiveType}}{{^isContainer}}crate::models::{{/isContainer}}{{/isPrimitiveType}}{{{dataType}}}{{/isUuid}}{{/isString}}{{^required}}>{{/required}}{{#required}}{{#isNullable}}>{{/isNullable}}{{/required}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) -> Result<{{#supportMultipleResponses}}ResponseContent<{{{operationIdCamelCase}}}Success>{{/supportMultipleResponses}}{{^supportMultipleResponses}}{{^returnType}}(){{/returnType}}{{#returnType}}{{{returnType}}}{{/returnType}}{{/supportMultipleResponses}}, Error<{{{operationIdCamelCase}}}Error>> {
-    {{/vendorExtensions.x-group-parameters}}
-        {{^supportAsync}}
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        {{/supportAsync}}
-        let client = &configuration.client;
+    let client = &configuration.client;
 
-        let uri_str = format!("{}{{{path}}}", configuration.base_path{{#pathParams}}, {{{baseName}}}={{#isString}}crate::apis::urlencode({{/isString}}{{{paramName}}}{{^required}}.unwrap(){{/required}}{{#required}}{{#isNullable}}.unwrap(){{/isNullable}}{{/required}}{{#isListContainer}}.join(",").as_ref(){{/isListContainer}}{{#isString}}){{/isString}}{{/pathParams}});
-        let mut req_builder = client.{{{httpMethod}}}(uri_str.as_str());
+    let uri_str = format!("{}{{{path}}}", configuration.base_path{{#pathParams}}, {{{baseName}}}={{#isString}}crate::apis::urlencode({{/isString}}{{{paramName}}}{{^required}}.unwrap(){{/required}}{{#required}}{{#isNullable}}.unwrap(){{/isNullable}}{{/required}}{{#isListContainer}}.join(",").as_ref(){{/isListContainer}}{{#isString}}){{/isString}}{{/pathParams}});
+    let mut req_builder = client.{{{httpMethod}}}(uri_str.as_str());
 
-        {{#queryParams}}
-        {{#required}}
-        req_builder = req_builder.query(&[("{{{baseName}}}", &{{{paramName}}}{{#isListContainer}}.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(","){{/isListContainer}}.to_string())]);
-        {{/required}}
-        {{^required}}
-        if let Some(ref s) = {{{paramName}}} {
-            req_builder = req_builder.query(&[("{{{baseName}}}", &s{{#isListContainer}}.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(","){{/isListContainer}}.to_string())]);
-        }
-        {{/required}}
-        {{/queryParams}}
-        {{#hasAuthMethods}}
-        {{#authMethods}}
-        {{#isApiKey}}
-        {{#isKeyInQuery}}
-        if let Some(ref apikey) = configuration.api_key {
-            let key = apikey.key.clone();
-            let val = match apikey.prefix {
-                Some(ref prefix) => format!("{} {}", prefix, key),
-                None => key,
-            };
-            req_builder = req_builder.query(&[("{{{keyParamName}}}", val)]);
-        }
-        {{/isKeyInQuery}}
-        {{/isApiKey}}
-        {{/authMethods}}
-        {{/hasAuthMethods}}
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        {{#hasHeaderParams}}
-        {{#headerParams}}
-        {{#required}}
-        {{^isNullable}}
-        req_builder = req_builder.header("{{{baseName}}}", {{{paramName}}}{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
-        {{/isNullable}}
-        {{#isNullable}}
-        match {{{paramName}}} {
-            Some(param_value) => { req_builder = req_builder.header("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string()); },
-            None => { req_builder = req_builder.header("{{{baseName}}}", ""); },
-        }
-        {{/isNullable}}
-        {{/required}}
-        {{^required}}
-        if let Some(param_value) = {{{paramName}}} {
-            req_builder = req_builder.header("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
-        }
-        {{/required}}
-        {{/headerParams}}
-        {{/hasHeaderParams}}
-        {{#hasAuthMethods}}
-        {{#authMethods}}
-        {{#isApiKey}}
-        {{#isKeyInHeader}}
-        if let Some(ref apikey) = configuration.api_key {
-            let key = apikey.key.clone();
-            let val = match apikey.prefix {
-                Some(ref prefix) => format!("{} {}", prefix, key),
-                None => key,
-            };
-            req_builder = req_builder.header("{{{keyParamName}}}", val);
-        };
-        {{/isKeyInHeader}}
-        {{/isApiKey}}
-        {{#isBasic}}
-        {{#isBasicBasic}}
-        if let Some(ref auth_conf) = configuration.basic_auth {
-            req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
-        };
-        {{/isBasicBasic}}
-        {{#isBasicBearer}}
-        if let Some(ref token) = configuration.bearer_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        {{/isBasicBearer}}
-        {{/isBasic}}
-        {{#isOAuth}}
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        {{/isOAuth}}
-        {{/authMethods}}
-        {{/hasAuthMethods}}
-        {{#isMultipart}}
-        {{#hasFormParams}}
-        let mut form = reqwest::multipart::Form::new();
-        {{#formParams}}
-        {{#isFile}}
-        {{^supportAsync}}
-        {{#required}}
-        {{^isNullable}}
-        form = form.file("{{{baseName}}}", {{{paramName}}})?;
-        {{/isNullable}}
-        {{#isNullable}}
-        match {{{paramName}}} {
-            Some(param_value) => { form = form.file("{{{baseName}}}", param_value)?; },
-            None => { unimplemented!("Required nullable form file param not supported"); },
-        }
-        {{/isNullable}}
-        {{/required}}
-        {{^required}}
-        if let Some(param_value) = {{{paramName}}} {
-            form = form.file("{{{baseName}}}", param_value)?;
-        }
-        {{/required}}
-        {{/supportAsync}}
-        {{#supportAsync}}
-        // TODO: support file upload for '{{{baseName}}}' parameter
-        {{/supportAsync}}
-        {{/isFile}}
-        {{^isFile}}
-        {{#required}}
-        {{^isNullable}}
-        form = form.text("{{{baseName}}}", {{{paramName}}}{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
-        {{/isNullable}}
-        {{#isNullable}}
-        match {{{paramName}}} {
-            Some(param_value) => { form = form.text("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string()); },
-            None => { form = form.text("{{{baseName}}}", ""); },
-        }
-        {{/isNullable}}
-        {{/required}}
-        {{^required}}
-        if let Some(param_value) = {{{paramName}}} {
-            form = form.text("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
-        }
-        {{/required}}
-        {{/isFile}}
-        {{/formParams}}
-        req_builder = req_builder.multipart(form);
-        {{/hasFormParams}}
-        {{/isMultipart}}
-        {{^isMultipart}}
-        {{#hasFormParams}}
-        let mut form_params = std::collections::HashMap::new();
-        {{#formParams}}
-        {{#isFile}}
-        {{#required}}
-        {{^isNullable}}
-        form_params.insert("{{{baseName}}}", unimplemented!("File form param not supported with x-www-form-urlencoded content"));
-        {{/isNullable}}
-        {{#isNullable}}
-        match {{{paramName}}} {
-            Some(param_value) => { form_params.insert("{{{baseName}}}", unimplemented!("File form param not supported with x-www-form-urlencoded content")); },
-            None => { unimplemented!("Required nullable file form param not supported with x-www-form-urlencoded content"); },
-        }
-        {{/isNullable}}
-        {{/required}}
-        {{^required}}
-        if let Some(param_value) = {{{paramName}}} {
-            form_params.insert("{{{baseName}}}", unimplemented!("File form param not supported with x-www-form-urlencoded content"));
-        }
-        {{/required}}
-        {{/isFile}}
-        {{^isFile}}
-        {{#required}}
-        {{^isNullable}}
-        form_params.insert("{{{baseName}}}", {{{paramName}}}{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
-        {{/isNullable}}
-        {{#isNullable}}
-        match {{{paramName}}} {
-            Some(param_value) => { form_params.insert("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string()); },
-            None => { form_params.insert("{{{baseName}}}", ""); },
-        }
-        {{/isNullable}}
-        {{/required}}
-        {{^required}}
-        if let Some(param_value) = {{{paramName}}} {
-            form_params.insert("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
-        }
-        {{/required}}
-        {{/isFile}}
-        {{/formParams}}
-        req_builder = req_builder.form(&form_params);
-        {{/hasFormParams}}
-        {{/isMultipart}}
-        {{#hasBodyParam}}
-        {{#bodyParams}}
-        req_builder = req_builder.json(&{{{paramName}}});
-        {{/bodyParams}}
-        {{/hasBodyParam}}
-
-        let req = req_builder.build()?;
-        let {{^supportAsync}}mut {{/supportAsync}}resp = client.execute(req){{#supportAsync}}.await{{/supportAsync}}?;
-
-        let status = resp.status();
-        let content = resp.text(){{#supportAsync}}.await{{/supportAsync}}?;
-
-        if status.is_success() {
-            {{^supportMultipleResponses}}
-            {{^returnType}}
-            Ok(())
-            {{/returnType}}
-            {{#returnType}}
-            serde_json::from_str(&content).map_err(Error::from)
-            {{/returnType}}
-            {{/supportMultipleResponses}}
-            {{#supportMultipleResponses}}
-            let entity: Option<{{{operationIdCamelCase}}}Success> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-            {{/supportMultipleResponses}}
-        } else {
-            let entity: Option<{{{operationIdCamelCase}}}Error> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    {{#queryParams}}
+    {{#required}}
+    req_builder = req_builder.query(&[("{{{baseName}}}", &{{{paramName}}}{{#isListContainer}}.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(","){{/isListContainer}}.to_string())]);
+    {{/required}}
+    {{^required}}
+    if let Some(ref s) = {{{paramName}}} {
+        req_builder = req_builder.query(&[("{{{baseName}}}", &s{{#isListContainer}}.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(","){{/isListContainer}}.to_string())]);
     }
+    {{/required}}
+    {{/queryParams}}
+    {{#hasAuthMethods}}
+    {{#authMethods}}
+    {{#isApiKey}}
+    {{#isKeyInQuery}}
+    if let Some(ref apikey) = configuration.api_key {
+        let key = apikey.key.clone();
+        let val = match apikey.prefix {
+            Some(ref prefix) => format!("{} {}", prefix, key),
+            None => key,
+        };
+        req_builder = req_builder.query(&[("{{{keyParamName}}}", val)]);
+    }
+    {{/isKeyInQuery}}
+    {{/isApiKey}}
+    {{/authMethods}}
+    {{/hasAuthMethods}}
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    {{#hasHeaderParams}}
+    {{#headerParams}}
+    {{#required}}
+    {{^isNullable}}
+    req_builder = req_builder.header("{{{baseName}}}", {{{paramName}}}{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
+    {{/isNullable}}
+    {{#isNullable}}
+    match {{{paramName}}} {
+        Some(param_value) => { req_builder = req_builder.header("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string()); },
+        None => { req_builder = req_builder.header("{{{baseName}}}", ""); },
+    }
+    {{/isNullable}}
+    {{/required}}
+    {{^required}}
+    if let Some(param_value) = {{{paramName}}} {
+        req_builder = req_builder.header("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
+    }
+    {{/required}}
+    {{/headerParams}}
+    {{/hasHeaderParams}}
+    {{#hasAuthMethods}}
+    {{#authMethods}}
+    {{#isApiKey}}
+    {{#isKeyInHeader}}
+    if let Some(ref apikey) = configuration.api_key {
+        let key = apikey.key.clone();
+        let val = match apikey.prefix {
+            Some(ref prefix) => format!("{} {}", prefix, key),
+            None => key,
+        };
+        req_builder = req_builder.header("{{{keyParamName}}}", val);
+    };
+    {{/isKeyInHeader}}
+    {{/isApiKey}}
+    {{#isBasic}}
+    {{#isBasicBasic}}
+    if let Some(ref auth_conf) = configuration.basic_auth {
+        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
+    };
+    {{/isBasicBasic}}
+    {{#isBasicBearer}}
+    if let Some(ref token) = configuration.bearer_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    {{/isBasicBearer}}
+    {{/isBasic}}
+    {{#isOAuth}}
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    {{/isOAuth}}
+    {{/authMethods}}
+    {{/hasAuthMethods}}
+    {{#isMultipart}}
+    {{#hasFormParams}}
+    let mut form = reqwest::multipart::Form::new();
+    {{#formParams}}
+    {{#isFile}}
+    {{^supportAsync}}
+    {{#required}}
+    {{^isNullable}}
+    form = form.file("{{{baseName}}}", {{{paramName}}})?;
+    {{/isNullable}}
+    {{#isNullable}}
+    match {{{paramName}}} {
+        Some(param_value) => { form = form.file("{{{baseName}}}", param_value)?; },
+        None => { unimplemented!("Required nullable form file param not supported"); },
+    }
+    {{/isNullable}}
+    {{/required}}
+    {{^required}}
+    if let Some(param_value) = {{{paramName}}} {
+        form = form.file("{{{baseName}}}", param_value)?;
+    }
+    {{/required}}
+    {{/supportAsync}}
+    {{#supportAsync}}
+    // TODO: support file upload for '{{{baseName}}}' parameter
+    {{/supportAsync}}
+    {{/isFile}}
+    {{^isFile}}
+    {{#required}}
+    {{^isNullable}}
+    form = form.text("{{{baseName}}}", {{{paramName}}}{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
+    {{/isNullable}}
+    {{#isNullable}}
+    match {{{paramName}}} {
+        Some(param_value) => { form = form.text("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string()); },
+        None => { form = form.text("{{{baseName}}}", ""); },
+    }
+    {{/isNullable}}
+    {{/required}}
+    {{^required}}
+    if let Some(param_value) = {{{paramName}}} {
+        form = form.text("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
+    }
+    {{/required}}
+    {{/isFile}}
+    {{/formParams}}
+    req_builder = req_builder.multipart(form);
+    {{/hasFormParams}}
+    {{/isMultipart}}
+    {{^isMultipart}}
+    {{#hasFormParams}}
+    let mut form_params = std::collections::HashMap::new();
+    {{#formParams}}
+    {{#isFile}}
+    {{#required}}
+    {{^isNullable}}
+    form_params.insert("{{{baseName}}}", unimplemented!("File form param not supported with x-www-form-urlencoded content"));
+    {{/isNullable}}
+    {{#isNullable}}
+    match {{{paramName}}} {
+        Some(param_value) => { form_params.insert("{{{baseName}}}", unimplemented!("File form param not supported with x-www-form-urlencoded content")); },
+        None => { unimplemented!("Required nullable file form param not supported with x-www-form-urlencoded content"); },
+    }
+    {{/isNullable}}
+    {{/required}}
+    {{^required}}
+    if let Some(param_value) = {{{paramName}}} {
+        form_params.insert("{{{baseName}}}", unimplemented!("File form param not supported with x-www-form-urlencoded content"));
+    }
+    {{/required}}
+    {{/isFile}}
+    {{^isFile}}
+    {{#required}}
+    {{^isNullable}}
+    form_params.insert("{{{baseName}}}", {{{paramName}}}{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
+    {{/isNullable}}
+    {{#isNullable}}
+    match {{{paramName}}} {
+        Some(param_value) => { form_params.insert("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string()); },
+        None => { form_params.insert("{{{baseName}}}", ""); },
+    }
+    {{/isNullable}}
+    {{/required}}
+    {{^required}}
+    if let Some(param_value) = {{{paramName}}} {
+        form_params.insert("{{{baseName}}}", param_value{{#isListContainer}}.join(","){{/isListContainer}}.to_string());
+    }
+    {{/required}}
+    {{/isFile}}
+    {{/formParams}}
+    req_builder = req_builder.form(&form_params);
+    {{/hasFormParams}}
+    {{/isMultipart}}
+    {{#hasBodyParam}}
+    {{#bodyParams}}
+    req_builder = req_builder.json(&{{{paramName}}});
+    {{/bodyParams}}
+    {{/hasBodyParam}}
+
+    let req = req_builder.build()?;
+    let {{^supportAsync}}mut {{/supportAsync}}resp = client.execute(req){{#supportAsync}}.await{{/supportAsync}}?;
+
+    let status = resp.status();
+    let content = resp.text(){{#supportAsync}}.await{{/supportAsync}}?;
+
+    if status.is_success() {
+        {{^supportMultipleResponses}}
+        {{^returnType}}
+        Ok(())
+        {{/returnType}}
+        {{#returnType}}
+        serde_json::from_str(&content).map_err(Error::from)
+        {{/returnType}}
+        {{/supportMultipleResponses}}
+        {{#supportMultipleResponses}}
+        let entity: Option<{{{operationIdCamelCase}}}Success> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+        {{/supportMultipleResponses}}
+    } else {
+        let entity: Option<{{{operationIdCamelCase}}}Error> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 
 {{/operation}}
 {{/operations}}
-{{^supportAsync}}
-}
-{{/supportAsync}}

modules/openapi-generator/src/main/resources/rust/reqwest/api_mod.mustache

@@ -44,7 +44,4 @@ pub mod {{{classFilename}}};
 {{/apis}}
 {{/apiInfo}}
 
-{{^supportAsync}}
-pub mod client;
-{{/supportAsync}}
 pub mod configuration;

modules/openapi-generator/src/main/resources/rust/reqwest/client.mustache

@@ -1,52 +0,0 @@
-use std::rc::Rc;
-
-use super::configuration::Configuration;
-
-pub struct APIClient {
-{{#apiInfo}}
-{{#apis}}
-{{#operations}}
-{{#operation}}
-    {{#-last}}
-    {{{classFilename}}}: Box<dyn crate::apis::{{{classFilename}}}::{{{classname}}}>,
-    {{/-last}}
-{{/operation}}
-{{/operations}}
-{{/apis}}
-{{/apiInfo}}
-}
-
-impl APIClient {
-    pub fn new(configuration: Configuration) -> APIClient {
-        let rc = Rc::new(configuration);
-
-        APIClient {
-{{#apiInfo}}
-{{#apis}}
-{{#operations}}
-{{#operation}}
-            {{#-last}}
-            {{{classFilename}}}: Box::new(crate::apis::{{{classFilename}}}::{{{classname}}}Client::new(rc.clone())),
-            {{/-last}}
-{{/operation}}
-{{/operations}}
-{{/apis}}
-{{/apiInfo}}
-        }
-    }
-
-{{#apiInfo}}
-{{#apis}}
-{{#operations}}
-{{#operation}}
-{{#-last}}
-    pub fn {{{classFilename}}}(&self) -> &dyn crate::apis::{{{classFilename}}}::{{{classname}}}{
-        self.{{{classFilename}}}.as_ref()
-    }
-
-{{/-last}}
-{{/operation}}
-{{/operations}}
-{{/apis}}
-{{/apiInfo}}
-}

samples/client/petstore/rust/reqwest/fileResponseTest/.openapi-generator/FILES

@@ -4,7 +4,6 @@ Cargo.toml
 README.md
 docs/DefaultApi.md
 git_push.sh
-src/apis/client.rs
 src/apis/configuration.rs
 src/apis/default_api.rs
 src/apis/mod.rs

samples/client/petstore/rust/reqwest/fileResponseTest/src/apis/default_api.rs

@@ -8,28 +8,12 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-use std::borrow::Borrow;
-use std::option::Option;
 
 use reqwest;
 
 use crate::apis::ResponseContent;
 use super::{Error, configuration};
 
-pub struct DefaultApiClient {
-    configuration: Rc<configuration::Configuration>,
-}
-
-impl DefaultApiClient {
-    pub fn new(configuration: Rc<configuration::Configuration>) -> DefaultApiClient {
-        DefaultApiClient {
-            configuration,
-        }
-    }
-}
-
 
 /// struct for typed errors of method `fileresponsetest`
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -39,35 +23,29 @@ pub enum FileresponsetestError {
 }
 
 
-pub trait DefaultApi {
-    fn fileresponsetest(&self, ) -> Result<std::path::PathBuf, Error<FileresponsetestError>>;
-}
+pub fn fileresponsetest(configuration: &configuration::Configuration, ) -> Result<std::path::PathBuf, Error<FileresponsetestError>> {
 
-impl DefaultApi for DefaultApiClient {
-    fn fileresponsetest(&self, ) -> Result<std::path::PathBuf, Error<FileresponsetestError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+    let client = &configuration.client;
 
-        let uri_str = format!("{}/tests/fileResponse", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    let uri_str = format!("{}/tests/fileResponse", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<FileresponsetestError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<FileresponsetestError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
 }
+

samples/client/petstore/rust/reqwest/fileResponseTest/src/apis/mod.rs

@@ -40,5 +40,4 @@ pub fn urlencode<T: AsRef<str>>(s: T) -> String {
 
 pub mod default_api;
 
-pub mod client;
 pub mod configuration;

samples/client/petstore/rust/reqwest/petstore-async/src/apis/pet_api.rs

@@ -8,10 +8,6 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-
-use std::option::Option;
 
 use reqwest;
 
@@ -211,298 +207,309 @@ pub enum UploadFileError {
 }
 
 
-    pub async fn add_pet(configuration: &configuration::Configuration, params: AddPetParams) -> Result<ResponseContent<AddPetSuccess>, Error<AddPetError>> {
-        // unbox the parameters
-        let body = params.body;
+pub async fn add_pet(configuration: &configuration::Configuration, params: AddPetParams) -> Result<ResponseContent<AddPetSuccess>, Error<AddPetError>> {
+    // unbox the parameters
+    let body = params.body;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/pet", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        req_builder = req_builder.json(&body);
+    let uri_str = format!("{}/pet", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<AddPetSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<AddPetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    req_builder = req_builder.json(&body);
 
-    pub async fn delete_pet(configuration: &configuration::Configuration, params: DeletePetParams) -> Result<ResponseContent<DeletePetSuccess>, Error<DeletePetError>> {
-        // unbox the parameters
-        let pet_id = params.pet_id;
-        let api_key = params.api_key;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.delete(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(param_value) = api_key {
-            req_builder = req_builder.header("api_key", param_value.to_string());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<DeletePetSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<DeletePetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<AddPetSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<AddPetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
+}
 
-    pub async fn find_pets_by_status(configuration: &configuration::Configuration, params: FindPetsByStatusParams) -> Result<ResponseContent<FindPetsByStatusSuccess>, Error<FindPetsByStatusError>> {
-        // unbox the parameters
-        let status = params.status;
+pub async fn delete_pet(configuration: &configuration::Configuration, params: DeletePetParams) -> Result<ResponseContent<DeletePetSuccess>, Error<DeletePetError>> {
+    // unbox the parameters
+    let pet_id = params.pet_id;
+    let api_key = params.api_key;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    let client = &configuration.client;
 
-        req_builder = req_builder.query(&[("status", &status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.delete(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<FindPetsByStatusSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<FindPetsByStatusError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-
-    pub async fn find_pets_by_tags(configuration: &configuration::Configuration, params: FindPetsByTagsParams) -> Result<ResponseContent<FindPetsByTagsSuccess>, Error<FindPetsByTagsError>> {
-        // unbox the parameters
-        let tags = params.tags;
-
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet/findByTags", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        req_builder = req_builder.query(&[("tags", &tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<FindPetsByTagsSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<FindPetsByTagsError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(param_value) = api_key {
+        req_builder = req_builder.header("api_key", param_value.to_string());
     }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
 
-    pub async fn get_pet_by_id(configuration: &configuration::Configuration, params: GetPetByIdParams) -> Result<ResponseContent<GetPetByIdSuccess>, Error<GetPetByIdError>> {
-        // unbox the parameters
-        let pet_id = params.pet_id;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref apikey) = configuration.api_key {
-            let key = apikey.key.clone();
-            let val = match apikey.prefix {
-                Some(ref prefix) => format!("{} {}", prefix, key),
-                None => key,
-            };
-            req_builder = req_builder.header("api_key", val);
-        };
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<GetPetByIdSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<GetPetByIdError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<DeletePetSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<DeletePetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
+}
 
-    pub async fn update_pet(configuration: &configuration::Configuration, params: UpdatePetParams) -> Result<ResponseContent<UpdatePetSuccess>, Error<UpdatePetError>> {
-        // unbox the parameters
-        let body = params.body;
+/// Multiple status values can be provided with comma separated strings
+pub async fn find_pets_by_status(configuration: &configuration::Configuration, params: FindPetsByStatusParams) -> Result<ResponseContent<FindPetsByStatusSuccess>, Error<FindPetsByStatusError>> {
+    // unbox the parameters
+    let status = params.status;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/pet", configuration.base_path);
-        let mut req_builder = client.put(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        req_builder = req_builder.json(&body);
+    let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<UpdatePetSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<UpdatePetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    req_builder = req_builder.query(&[("status", &status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
 
-    pub async fn update_pet_with_form(configuration: &configuration::Configuration, params: UpdatePetWithFormParams) -> Result<ResponseContent<UpdatePetWithFormSuccess>, Error<UpdatePetWithFormError>> {
-        // unbox the parameters
-        let pet_id = params.pet_id;
-        let name = params.name;
-        let status = params.status;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.post(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        let mut form_params = std::collections::HashMap::new();
-        if let Some(param_value) = name {
-            form_params.insert("name", param_value.to_string());
-        }
-        if let Some(param_value) = status {
-            form_params.insert("status", param_value.to_string());
-        }
-        req_builder = req_builder.form(&form_params);
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<UpdatePetWithFormSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<UpdatePetWithFormError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<FindPetsByStatusSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<FindPetsByStatusError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
+}
 
-    pub async fn upload_file(configuration: &configuration::Configuration, params: UploadFileParams) -> Result<ResponseContent<UploadFileSuccess>, Error<UploadFileError>> {
-        // unbox the parameters
-        let pet_id = params.pet_id;
-        let additional_metadata = params.additional_metadata;
-        let file = params.file;
+/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+pub async fn find_pets_by_tags(configuration: &configuration::Configuration, params: FindPetsByTagsParams) -> Result<ResponseContent<FindPetsByTagsSuccess>, Error<FindPetsByTagsError>> {
+    // unbox the parameters
+    let tags = params.tags;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.post(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        let mut form = reqwest::multipart::Form::new();
-        if let Some(param_value) = additional_metadata {
-            form = form.text("additionalMetadata", param_value.to_string());
-        }
-        // TODO: support file upload for 'file' parameter
-        req_builder = req_builder.multipart(form);
+    let uri_str = format!("{}/pet/findByTags", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<UploadFileSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<UploadFileError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    req_builder = req_builder.query(&[("tags", &tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<FindPetsByTagsSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<FindPetsByTagsError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// Returns a single pet
+pub async fn get_pet_by_id(configuration: &configuration::Configuration, params: GetPetByIdParams) -> Result<ResponseContent<GetPetByIdSuccess>, Error<GetPetByIdError>> {
+    // unbox the parameters
+    let pet_id = params.pet_id;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref apikey) = configuration.api_key {
+        let key = apikey.key.clone();
+        let val = match apikey.prefix {
+            Some(ref prefix) => format!("{} {}", prefix, key),
+            None => key,
+        };
+        req_builder = req_builder.header("api_key", val);
+    };
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<GetPetByIdSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<GetPetByIdError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub async fn update_pet(configuration: &configuration::Configuration, params: UpdatePetParams) -> Result<ResponseContent<UpdatePetSuccess>, Error<UpdatePetError>> {
+    // unbox the parameters
+    let body = params.body;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet", configuration.base_path);
+    let mut req_builder = client.put(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<UpdatePetSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<UpdatePetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub async fn update_pet_with_form(configuration: &configuration::Configuration, params: UpdatePetWithFormParams) -> Result<ResponseContent<UpdatePetWithFormSuccess>, Error<UpdatePetWithFormError>> {
+    // unbox the parameters
+    let pet_id = params.pet_id;
+    let name = params.name;
+    let status = params.status;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    let mut form_params = std::collections::HashMap::new();
+    if let Some(param_value) = name {
+        form_params.insert("name", param_value.to_string());
+    }
+    if let Some(param_value) = status {
+        form_params.insert("status", param_value.to_string());
+    }
+    req_builder = req_builder.form(&form_params);
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<UpdatePetWithFormSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<UpdatePetWithFormError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub async fn upload_file(configuration: &configuration::Configuration, params: UploadFileParams) -> Result<ResponseContent<UploadFileSuccess>, Error<UploadFileError>> {
+    // unbox the parameters
+    let pet_id = params.pet_id;
+    let additional_metadata = params.additional_metadata;
+    let file = params.file;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    let mut form = reqwest::multipart::Form::new();
+    if let Some(param_value) = additional_metadata {
+        form = form.text("additionalMetadata", param_value.to_string());
+    }
+    // TODO: support file upload for 'file' parameter
+    req_builder = req_builder.multipart(form);
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<UploadFileSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<UploadFileError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 

samples/client/petstore/rust/reqwest/petstore-async/src/apis/store_api.rs

@@ -8,10 +8,6 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-
-use std::option::Option;
 
 use reqwest;
 
@@ -105,131 +101,138 @@ pub enum PlaceOrderError {
 }
 
 
-    pub async fn delete_order(configuration: &configuration::Configuration, params: DeleteOrderParams) -> Result<ResponseContent<DeleteOrderSuccess>, Error<DeleteOrderError>> {
-        // unbox the parameters
-        let order_id = params.order_id;
+/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+pub async fn delete_order(configuration: &configuration::Configuration, params: DeleteOrderParams) -> Result<ResponseContent<DeleteOrderSuccess>, Error<DeleteOrderError>> {
+    // unbox the parameters
+    let order_id = params.order_id;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(order_id));
-        let mut req_builder = client.delete(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(order_id));
+    let mut req_builder = client.delete(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<DeleteOrderSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<DeleteOrderError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    pub async fn get_inventory(configuration: &configuration::Configuration) -> Result<ResponseContent<GetInventorySuccess>, Error<GetInventoryError>> {
-        // unbox the parameters
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/store/inventory", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    if status.is_success() {
+        let entity: Option<DeleteOrderSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<DeleteOrderError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref apikey) = configuration.api_key {
-            let key = apikey.key.clone();
-            let val = match apikey.prefix {
-                Some(ref prefix) => format!("{} {}", prefix, key),
-                None => key,
-            };
-            req_builder = req_builder.header("api_key", val);
+/// Returns a map of status codes to quantities
+pub async fn get_inventory(configuration: &configuration::Configuration) -> Result<ResponseContent<GetInventorySuccess>, Error<GetInventoryError>> {
+    // unbox the parameters
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/store/inventory", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref apikey) = configuration.api_key {
+        let key = apikey.key.clone();
+        let val = match apikey.prefix {
+            Some(ref prefix) => format!("{} {}", prefix, key),
+            None => key,
         };
+        req_builder = req_builder.header("api_key", val);
+    };
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let status = resp.status();
-        let content = resp.text().await?;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        if status.is_success() {
-            let entity: Option<GetInventorySuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<GetInventoryError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<GetInventorySuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<GetInventoryError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
+pub async fn get_order_by_id(configuration: &configuration::Configuration, params: GetOrderByIdParams) -> Result<ResponseContent<GetOrderByIdSuccess>, Error<GetOrderByIdError>> {
+    // unbox the parameters
+    let order_id = params.order_id;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=order_id);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    pub async fn get_order_by_id(configuration: &configuration::Configuration, params: GetOrderByIdParams) -> Result<ResponseContent<GetOrderByIdSuccess>, Error<GetOrderByIdError>> {
-        // unbox the parameters
-        let order_id = params.order_id;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=order_id);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<GetOrderByIdSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<GetOrderByIdError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<GetOrderByIdSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<GetOrderByIdError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
+}
 
-    pub async fn place_order(configuration: &configuration::Configuration, params: PlaceOrderParams) -> Result<ResponseContent<PlaceOrderSuccess>, Error<PlaceOrderError>> {
-        // unbox the parameters
-        let body = params.body;
+pub async fn place_order(configuration: &configuration::Configuration, params: PlaceOrderParams) -> Result<ResponseContent<PlaceOrderSuccess>, Error<PlaceOrderError>> {
+    // unbox the parameters
+    let body = params.body;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/store/order", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
+    let uri_str = format!("{}/store/order", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<PlaceOrderSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<PlaceOrderError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<PlaceOrderSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<PlaceOrderError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 

samples/client/petstore/rust/reqwest/petstore-async/src/apis/user_api.rs

@@ -8,10 +8,6 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-
-use std::option::Option;
 
 use reqwest;
 
@@ -198,250 +194,261 @@ pub enum UpdateUserError {
 }
 
 
-    pub async fn create_user(configuration: &configuration::Configuration, params: CreateUserParams) -> Result<ResponseContent<CreateUserSuccess>, Error<CreateUserError>> {
-        // unbox the parameters
-        let body = params.body;
+/// This can only be done by the logged in user.
+pub async fn create_user(configuration: &configuration::Configuration, params: CreateUserParams) -> Result<ResponseContent<CreateUserSuccess>, Error<CreateUserError>> {
+    // unbox the parameters
+    let body = params.body;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/user", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
+    let uri_str = format!("{}/user", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
 
-        let status = resp.status();
-        let content = resp.text().await?;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        if status.is_success() {
-            let entity: Option<CreateUserSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<CreateUserSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub async fn create_users_with_array_input(configuration: &configuration::Configuration, params: CreateUsersWithArrayInputParams) -> Result<ResponseContent<CreateUsersWithArrayInputSuccess>, Error<CreateUsersWithArrayInputError>> {
+    // unbox the parameters
+    let body = params.body;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/createWithArray", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<CreateUsersWithArrayInputSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<CreateUsersWithArrayInputError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub async fn create_users_with_list_input(configuration: &configuration::Configuration, params: CreateUsersWithListInputParams) -> Result<ResponseContent<CreateUsersWithListInputSuccess>, Error<CreateUsersWithListInputError>> {
+    // unbox the parameters
+    let body = params.body;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/createWithList", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
+
+    let status = resp.status();
+    let content = resp.text().await?;
+
+    if status.is_success() {
+        let entity: Option<CreateUsersWithListInputSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<CreateUsersWithListInputError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// This can only be done by the logged in user.
+pub async fn delete_user(configuration: &configuration::Configuration, params: DeleteUserParams) -> Result<ResponseContent<DeleteUserSuccess>, Error<DeleteUserError>> {
+    // unbox the parameters
+    let username = params.username;
+
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
+    let mut req_builder = client.delete(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    pub async fn create_users_with_array_input(configuration: &configuration::Configuration, params: CreateUsersWithArrayInputParams) -> Result<ResponseContent<CreateUsersWithArrayInputSuccess>, Error<CreateUsersWithArrayInputError>> {
-        // unbox the parameters
-        let body = params.body;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/user/createWithArray", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    if status.is_success() {
+        let entity: Option<DeleteUserSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
+pub async fn get_user_by_name(configuration: &configuration::Configuration, params: GetUserByNameParams) -> Result<ResponseContent<GetUserByNameSuccess>, Error<GetUserByNameError>> {
+    // unbox the parameters
+    let username = params.username;
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
 
-        let status = resp.status();
-        let content = resp.text().await?;
+    let client = &configuration.client;
 
-        if status.is_success() {
-            let entity: Option<CreateUsersWithArrayInputSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<CreateUsersWithArrayInputError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    pub async fn create_users_with_list_input(configuration: &configuration::Configuration, params: CreateUsersWithListInputParams) -> Result<ResponseContent<CreateUsersWithListInputSuccess>, Error<CreateUsersWithListInputError>> {
-        // unbox the parameters
-        let body = params.body;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/user/createWithList", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    if status.is_success() {
+        let entity: Option<GetUserByNameSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<GetUserByNameError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
+pub async fn login_user(configuration: &configuration::Configuration, params: LoginUserParams) -> Result<ResponseContent<LoginUserSuccess>, Error<LoginUserError>> {
+    // unbox the parameters
+    let username = params.username;
+    let password = params.password;
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
 
-        let status = resp.status();
-        let content = resp.text().await?;
+    let client = &configuration.client;
 
-        if status.is_success() {
-            let entity: Option<CreateUsersWithListInputSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<CreateUsersWithListInputError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    let uri_str = format!("{}/user/login", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    req_builder = req_builder.query(&[("username", &username.to_string())]);
+    req_builder = req_builder.query(&[("password", &password.to_string())]);
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    pub async fn delete_user(configuration: &configuration::Configuration, params: DeleteUserParams) -> Result<ResponseContent<DeleteUserSuccess>, Error<DeleteUserError>> {
-        // unbox the parameters
-        let username = params.username;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
-        let mut req_builder = client.delete(uri_str.as_str());
+    if status.is_success() {
+        let entity: Option<LoginUserSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<LoginUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
+pub async fn logout_user(configuration: &configuration::Configuration) -> Result<ResponseContent<LogoutUserSuccess>, Error<LogoutUserError>> {
+    // unbox the parameters
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
 
-        let status = resp.status();
-        let content = resp.text().await?;
+    let client = &configuration.client;
 
-        if status.is_success() {
-            let entity: Option<DeleteUserSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    let uri_str = format!("{}/user/logout", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    pub async fn get_user_by_name(configuration: &configuration::Configuration, params: GetUserByNameParams) -> Result<ResponseContent<GetUserByNameSuccess>, Error<GetUserByNameError>> {
-        // unbox the parameters
-        let username = params.username;
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<GetUserByNameSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<GetUserByNameError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<LogoutUserSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<LogoutUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
+}
 
-    pub async fn login_user(configuration: &configuration::Configuration, params: LoginUserParams) -> Result<ResponseContent<LoginUserSuccess>, Error<LoginUserError>> {
-        // unbox the parameters
-        let username = params.username;
-        let password = params.password;
+/// This can only be done by the logged in user.
+pub async fn update_user(configuration: &configuration::Configuration, params: UpdateUserParams) -> Result<ResponseContent<UpdateUserSuccess>, Error<UpdateUserError>> {
+    // unbox the parameters
+    let username = params.username;
+    let body = params.body;
 
-        let client = &configuration.client;
 
-        let uri_str = format!("{}/user/login", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    let client = &configuration.client;
 
-        req_builder = req_builder.query(&[("username", &username.to_string())]);
-        req_builder = req_builder.query(&[("password", &password.to_string())]);
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
+    let mut req_builder = client.put(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<LoginUserSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<LoginUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
+    req_builder = req_builder.json(&body);
 
-    pub async fn logout_user(configuration: &configuration::Configuration) -> Result<ResponseContent<LogoutUserSuccess>, Error<LogoutUserError>> {
-        // unbox the parameters
+    let req = req_builder.build()?;
+    let resp = client.execute(req).await?;
 
-        let client = &configuration.client;
+    let status = resp.status();
+    let content = resp.text().await?;
 
-        let uri_str = format!("{}/user/logout", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<LogoutUserSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<LogoutUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    pub async fn update_user(configuration: &configuration::Configuration, params: UpdateUserParams) -> Result<ResponseContent<UpdateUserSuccess>, Error<UpdateUserError>> {
-        // unbox the parameters
-        let username = params.username;
-        let body = params.body;
-
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
-        let mut req_builder = client.put(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
-
-        let req = req_builder.build()?;
-        let resp = client.execute(req).await?;
-
-        let status = resp.status();
-        let content = resp.text().await?;
-
-        if status.is_success() {
-            let entity: Option<UpdateUserSuccess> = serde_json::from_str(&content).ok();
-            let result = ResponseContent { status, content, entity };
-            Ok(result)
-        } else {
-            let entity: Option<UpdateUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        let entity: Option<UpdateUserSuccess> = serde_json::from_str(&content).ok();
+        let result = ResponseContent { status, content, entity };
+        Ok(result)
+    } else {
+        let entity: Option<UpdateUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
+}
 

samples/client/petstore/rust/reqwest/petstore/.openapi-generator/FILES

@@ -12,7 +12,6 @@ docs/Tag.md
 docs/User.md
 docs/UserApi.md
 git_push.sh
-src/apis/client.rs
 src/apis/configuration.rs
 src/apis/mod.rs
 src/apis/pet_api.rs

samples/client/petstore/rust/reqwest/petstore/src/apis/client.rs

@@ -1,34 +0,0 @@
-use std::rc::Rc;
-
-use super::configuration::Configuration;
-
-pub struct APIClient {
-    pet_api: Box<dyn crate::apis::pet_api::PetApi>,
-    store_api: Box<dyn crate::apis::store_api::StoreApi>,
-    user_api: Box<dyn crate::apis::user_api::UserApi>,
-}
-
-impl APIClient {
-    pub fn new(configuration: Configuration) -> APIClient {
-        let rc = Rc::new(configuration);
-
-        APIClient {
-            pet_api: Box::new(crate::apis::pet_api::PetApiClient::new(rc.clone())),
-            store_api: Box::new(crate::apis::store_api::StoreApiClient::new(rc.clone())),
-            user_api: Box::new(crate::apis::user_api::UserApiClient::new(rc.clone())),
-        }
-    }
-
-    pub fn pet_api(&self) -> &dyn crate::apis::pet_api::PetApi{
-        self.pet_api.as_ref()
-    }
-
-    pub fn store_api(&self) -> &dyn crate::apis::store_api::StoreApi{
-        self.store_api.as_ref()
-    }
-
-    pub fn user_api(&self) -> &dyn crate::apis::user_api::UserApi{
-        self.user_api.as_ref()
-    }
-
-}

samples/client/petstore/rust/reqwest/petstore/src/apis/mod.rs

@@ -42,5 +42,4 @@ pub mod pet_api;
 pub mod store_api;
 pub mod user_api;
 
-pub mod client;
 pub mod configuration;

samples/client/petstore/rust/reqwest/petstore/src/apis/pet_api.rs

@@ -8,28 +8,12 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-use std::borrow::Borrow;
-use std::option::Option;
 
 use reqwest;
 
 use crate::apis::ResponseContent;
 use super::{Error, configuration};
 
-pub struct PetApiClient {
-    configuration: Rc<configuration::Configuration>,
-}
-
-impl PetApiClient {
-    pub fn new(configuration: Rc<configuration::Configuration>) -> PetApiClient {
-        PetApiClient {
-            configuration,
-        }
-    }
-}
-
 
 /// struct for typed errors of method `add_pet`
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -98,276 +82,266 @@ pub enum UploadFileError {
 }
 
 
-pub trait PetApi {
-    fn add_pet(&self, body: crate::models::Pet) -> Result<(), Error<AddPetError>>;
-    fn delete_pet(&self, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>>;
-    fn find_pets_by_status(&self, status: Vec<String>) -> Result<Vec<crate::models::Pet>, Error<FindPetsByStatusError>>;
-    fn find_pets_by_tags(&self, tags: Vec<String>) -> Result<Vec<crate::models::Pet>, Error<FindPetsByTagsError>>;
-    fn get_pet_by_id(&self, pet_id: i64) -> Result<crate::models::Pet, Error<GetPetByIdError>>;
-    fn update_pet(&self, body: crate::models::Pet) -> Result<(), Error<UpdatePetError>>;
-    fn update_pet_with_form(&self, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>>;
-    fn upload_file(&self, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<crate::models::ApiResponse, Error<UploadFileError>>;
+pub fn add_pet(configuration: &configuration::Configuration, body: crate::models::Pet) -> Result<(), Error<AddPetError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<AddPetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
 }
 
-impl PetApi for PetApiClient {
-    fn add_pet(&self, body: crate::models::Pet) -> Result<(), Error<AddPetError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
 
-        let uri_str = format!("{}/pet", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        req_builder = req_builder.json(&body);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.delete(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<AddPetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-
-    fn delete_pet(&self, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.delete(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(param_value) = api_key {
-            req_builder = req_builder.header("api_key", param_value.to_string());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<DeletePetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(param_value) = api_key {
+        req_builder = req_builder.header("api_key", param_value.to_string());
     }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
 
-    fn find_pets_by_status(&self, status: Vec<String>) -> Result<Vec<crate::models::Pet>, Error<FindPetsByStatusError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
 
-        let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    let status = resp.status();
+    let content = resp.text()?;
 
-        req_builder = req_builder.query(&[("status", &status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<FindPetsByStatusError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<DeletePetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
-
-    fn find_pets_by_tags(&self, tags: Vec<String>) -> Result<Vec<crate::models::Pet>, Error<FindPetsByTagsError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet/findByTags", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        req_builder = req_builder.query(&[("tags", &tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<FindPetsByTagsError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn get_pet_by_id(&self, pet_id: i64) -> Result<crate::models::Pet, Error<GetPetByIdError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref apikey) = configuration.api_key {
-            let key = apikey.key.clone();
-            let val = match apikey.prefix {
-                Some(ref prefix) => format!("{} {}", prefix, key),
-                None => key,
-            };
-            req_builder = req_builder.header("api_key", val);
-        };
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<GetPetByIdError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn update_pet(&self, body: crate::models::Pet) -> Result<(), Error<UpdatePetError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet", configuration.base_path);
-        let mut req_builder = client.put(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        req_builder = req_builder.json(&body);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<UpdatePetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn update_pet_with_form(&self, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.post(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        let mut form_params = std::collections::HashMap::new();
-        if let Some(param_value) = name {
-            form_params.insert("name", param_value.to_string());
-        }
-        if let Some(param_value) = status {
-            form_params.insert("status", param_value.to_string());
-        }
-        req_builder = req_builder.form(&form_params);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<UpdatePetWithFormError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn upload_file(&self, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<crate::models::ApiResponse, Error<UploadFileError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=pet_id);
-        let mut req_builder = client.post(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref token) = configuration.oauth_access_token {
-            req_builder = req_builder.bearer_auth(token.to_owned());
-        };
-        let mut form = reqwest::multipart::Form::new();
-        if let Some(param_value) = additional_metadata {
-            form = form.text("additionalMetadata", param_value.to_string());
-        }
-        if let Some(param_value) = file {
-            form = form.file("file", param_value)?;
-        }
-        req_builder = req_builder.multipart(form);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<UploadFileError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
 }
+
+/// Multiple status values can be provided with comma separated strings
+pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>) -> Result<Vec<crate::models::Pet>, Error<FindPetsByStatusError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    req_builder = req_builder.query(&[("status", &status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<FindPetsByStatusError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<crate::models::Pet>, Error<FindPetsByTagsError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/findByTags", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    req_builder = req_builder.query(&[("tags", &tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]);
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<FindPetsByTagsError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// Returns a single pet
+pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<crate::models::Pet, Error<GetPetByIdError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref apikey) = configuration.api_key {
+        let key = apikey.key.clone();
+        let val = match apikey.prefix {
+            Some(ref prefix) => format!("{} {}", prefix, key),
+            None => key,
+        };
+        req_builder = req_builder.header("api_key", val);
+    };
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<GetPetByIdError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn update_pet(configuration: &configuration::Configuration, body: crate::models::Pet) -> Result<(), Error<UpdatePetError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet", configuration.base_path);
+    let mut req_builder = client.put(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<UpdatePetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    let mut form_params = std::collections::HashMap::new();
+    if let Some(param_value) = name {
+        form_params.insert("name", param_value.to_string());
+    }
+    if let Some(param_value) = status {
+        form_params.insert("status", param_value.to_string());
+    }
+    req_builder = req_builder.form(&form_params);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<UpdatePetWithFormError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<crate::models::ApiResponse, Error<UploadFileError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=pet_id);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref token) = configuration.oauth_access_token {
+        req_builder = req_builder.bearer_auth(token.to_owned());
+    };
+    let mut form = reqwest::multipart::Form::new();
+    if let Some(param_value) = additional_metadata {
+        form = form.text("additionalMetadata", param_value.to_string());
+    }
+    if let Some(param_value) = file {
+        form = form.file("file", param_value)?;
+    }
+    req_builder = req_builder.multipart(form);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<UploadFileError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+

samples/client/petstore/rust/reqwest/petstore/src/apis/store_api.rs

@@ -8,28 +8,12 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-use std::borrow::Borrow;
-use std::option::Option;
 
 use reqwest;
 
 use crate::apis::ResponseContent;
 use super::{Error, configuration};
 
-pub struct StoreApiClient {
-    configuration: Rc<configuration::Configuration>,
-}
-
-impl StoreApiClient {
-    pub fn new(configuration: Rc<configuration::Configuration>) -> StoreApiClient {
-        StoreApiClient {
-            configuration,
-        }
-    }
-}
-
 
 /// struct for typed errors of method `delete_order`
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -65,125 +49,119 @@ pub enum PlaceOrderError {
 }
 
 
-pub trait StoreApi {
-    fn delete_order(&self, order_id: &str) -> Result<(), Error<DeleteOrderError>>;
-    fn get_inventory(&self, ) -> Result<::std::collections::HashMap<String, i32>, Error<GetInventoryError>>;
-    fn get_order_by_id(&self, order_id: i64) -> Result<crate::models::Order, Error<GetOrderByIdError>>;
-    fn place_order(&self, body: crate::models::Order) -> Result<crate::models::Order, Error<PlaceOrderError>>;
-}
+/// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
 
-impl StoreApi for StoreApiClient {
-    fn delete_order(&self, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+    let client = &configuration.client;
 
-        let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(order_id));
-        let mut req_builder = client.delete(uri_str.as_str());
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(order_id));
+    let mut req_builder = client.delete(uri_str.as_str());
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<DeleteOrderError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
-    fn get_inventory(&self, ) -> Result<::std::collections::HashMap<String, i32>, Error<GetInventoryError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
 
-        let uri_str = format!("{}/store/inventory", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    let status = resp.status();
+    let content = resp.text()?;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        if let Some(ref apikey) = configuration.api_key {
-            let key = apikey.key.clone();
-            let val = match apikey.prefix {
-                Some(ref prefix) => format!("{} {}", prefix, key),
-                None => key,
-            };
-            req_builder = req_builder.header("api_key", val);
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<DeleteOrderError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// Returns a map of status codes to quantities
+pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<::std::collections::HashMap<String, i32>, Error<GetInventoryError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/store/inventory", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    if let Some(ref apikey) = configuration.api_key {
+        let key = apikey.key.clone();
+        let val = match apikey.prefix {
+            Some(ref prefix) => format!("{} {}", prefix, key),
+            None => key,
         };
+        req_builder = req_builder.header("api_key", val);
+    };
 
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
 
-        let status = resp.status();
-        let content = resp.text()?;
+    let status = resp.status();
+    let content = resp.text()?;
 
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<GetInventoryError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<GetInventoryError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
-
-    fn get_order_by_id(&self, order_id: i64) -> Result<crate::models::Order, Error<GetOrderByIdError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=order_id);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<GetOrderByIdError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn place_order(&self, body: crate::models::Order) -> Result<crate::models::Order, Error<PlaceOrderError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/store/order", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<PlaceOrderError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
 }
+
+/// For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
+pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<crate::models::Order, Error<GetOrderByIdError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=order_id);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<GetOrderByIdError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn place_order(configuration: &configuration::Configuration, body: crate::models::Order) -> Result<crate::models::Order, Error<PlaceOrderError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/store/order", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<PlaceOrderError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+

samples/client/petstore/rust/reqwest/petstore/src/apis/user_api.rs

@@ -8,28 +8,12 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-use std::borrow::Borrow;
-use std::option::Option;
 
 use reqwest;
 
 use crate::apis::ResponseContent;
 use super::{Error, configuration};
 
-pub struct UserApiClient {
-    configuration: Rc<configuration::Configuration>,
-}
-
-impl UserApiClient {
-    pub fn new(configuration: Rc<configuration::Configuration>) -> UserApiClient {
-        UserApiClient {
-            configuration,
-        }
-    }
-}
-
 
 /// struct for typed errors of method `create_user`
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -99,230 +83,220 @@ pub enum UpdateUserError {
 }
 
 
-pub trait UserApi {
-    fn create_user(&self, body: crate::models::User) -> Result<(), Error<CreateUserError>>;
-    fn create_users_with_array_input(&self, body: Vec<crate::models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>>;
-    fn create_users_with_list_input(&self, body: Vec<crate::models::User>) -> Result<(), Error<CreateUsersWithListInputError>>;
-    fn delete_user(&self, username: &str) -> Result<(), Error<DeleteUserError>>;
-    fn get_user_by_name(&self, username: &str) -> Result<crate::models::User, Error<GetUserByNameError>>;
-    fn login_user(&self, username: &str, password: &str) -> Result<String, Error<LoginUserError>>;
-    fn logout_user(&self, ) -> Result<(), Error<LogoutUserError>>;
-    fn update_user(&self, username: &str, body: crate::models::User) -> Result<(), Error<UpdateUserError>>;
+/// This can only be done by the logged in user.
+pub fn create_user(configuration: &configuration::Configuration, body: crate::models::User) -> Result<(), Error<CreateUserError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
 }
 
-impl UserApi for UserApiClient {
-    fn create_user(&self, body: crate::models::User) -> Result<(), Error<CreateUserError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+pub fn create_users_with_array_input(configuration: &configuration::Configuration, body: Vec<crate::models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
 
-        let uri_str = format!("{}/user", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    let client = &configuration.client;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
+    let uri_str = format!("{}/user/createWithArray", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
 
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
+    req_builder = req_builder.json(&body);
 
-    fn create_users_with_array_input(&self, body: Vec<crate::models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
 
-        let uri_str = format!("{}/user/createWithArray", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
+    let status = resp.status();
+    let content = resp.text()?;
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<CreateUsersWithArrayInputError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<CreateUsersWithArrayInputError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
     }
-
-    fn create_users_with_list_input(&self, body: Vec<crate::models::User>) -> Result<(), Error<CreateUsersWithListInputError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/createWithList", configuration.base_path);
-        let mut req_builder = client.post(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<CreateUsersWithListInputError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn delete_user(&self, username: &str) -> Result<(), Error<DeleteUserError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
-        let mut req_builder = client.delete(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn get_user_by_name(&self, username: &str) -> Result<crate::models::User, Error<GetUserByNameError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<GetUserByNameError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn login_user(&self, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/login", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        req_builder = req_builder.query(&[("username", &username.to_string())]);
-        req_builder = req_builder.query(&[("password", &password.to_string())]);
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            serde_json::from_str(&content).map_err(Error::from)
-        } else {
-            let entity: Option<LoginUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn logout_user(&self, ) -> Result<(), Error<LogoutUserError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/logout", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<LogoutUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
-    fn update_user(&self, username: &str, body: crate::models::User) -> Result<(), Error<UpdateUserError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
-
-        let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
-        let mut req_builder = client.put(uri_str.as_str());
-
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-        req_builder = req_builder.json(&body);
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<UpdateUserError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
-    }
-
 }
+
+pub fn create_users_with_list_input(configuration: &configuration::Configuration, body: Vec<crate::models::User>) -> Result<(), Error<CreateUsersWithListInputError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/createWithList", configuration.base_path);
+    let mut req_builder = client.post(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<CreateUsersWithListInputError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// This can only be done by the logged in user.
+pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
+    let mut req_builder = client.delete(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<crate::models::User, Error<GetUserByNameError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<GetUserByNameError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/login", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    req_builder = req_builder.query(&[("username", &username.to_string())]);
+    req_builder = req_builder.query(&[("password", &password.to_string())]);
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        serde_json::from_str(&content).map_err(Error::from)
+    } else {
+        let entity: Option<LoginUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(), Error<LogoutUserError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/logout", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<LogoutUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+
+/// This can only be done by the logged in user.
+pub fn update_user(configuration: &configuration::Configuration, username: &str, body: crate::models::User) -> Result<(), Error<UpdateUserError>> {
+
+    let client = &configuration.client;
+
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(username));
+    let mut req_builder = client.put(uri_str.as_str());
+
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
+    }
+    req_builder = req_builder.json(&body);
+
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<UpdateUserError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
+}
+

samples/client/petstore/rust/reqwest/petstore/tests/pet_tests.rs

@@ -1,15 +1,12 @@
 extern crate petstore_reqwest;
-use petstore_reqwest::apis::pet_api::PetApi;
-use petstore_reqwest::apis::pet_api::PetApiClient;
+
+use petstore_reqwest::apis::pet_api::{add_pet, get_pet_by_id};
 use petstore_reqwest::apis::configuration;
 use petstore_reqwest::models::{Pet};
-use std::option::Option;
-use std::rc::Rc;
 
 #[test]
 fn test_pet() {
     let config = configuration::Configuration::new();
-    let pet_api_client = PetApiClient::new(Rc::new(config));
 
     // create pet object
     let photo_urls = vec!["https://11".to_string(), "https://22".to_string()];
@@ -17,10 +14,10 @@ fn test_pet() {
     new_pet.id = Option::Some(8787);
 
     // add pet
-    let _add_result = pet_api_client.add_pet(new_pet);
+    let _add_result = add_pet(&config, new_pet);
 
     // get pet
-    let pet_result = pet_api_client.get_pet_by_id(8787);
+    let pet_result = get_pet_by_id(&config, 8787);
 
     match pet_result {
         Ok(resp) => {

samples/client/petstore/rust/reqwest/rust-test/.openapi-generator/FILES

@@ -5,7 +5,6 @@ README.md
 docs/DefaultApi.md
 docs/TypeTesting.md
 git_push.sh
-src/apis/client.rs
 src/apis/configuration.rs
 src/apis/default_api.rs
 src/apis/mod.rs

samples/client/petstore/rust/reqwest/rust-test/src/apis/default_api.rs

@@ -8,28 +8,12 @@
  * Generated by: https://openapi-generator.tech
  */
 
-#[allow(unused_imports)]
-use std::rc::Rc;
-use std::borrow::Borrow;
-use std::option::Option;
 
 use reqwest;
 
 use crate::apis::ResponseContent;
 use super::{Error, configuration};
 
-pub struct DefaultApiClient {
-    configuration: Rc<configuration::Configuration>,
-}
-
-impl DefaultApiClient {
-    pub fn new(configuration: Rc<configuration::Configuration>) -> DefaultApiClient {
-        DefaultApiClient {
-            configuration,
-        }
-    }
-}
-
 
 /// struct for typed errors of method `dummy_get`
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -39,35 +23,29 @@ pub enum DummyGetError {
 }
 
 
-pub trait DefaultApi {
-    fn dummy_get(&self, ) -> Result<(), Error<DummyGetError>>;
-}
+pub fn dummy_get(configuration: &configuration::Configuration, ) -> Result<(), Error<DummyGetError>> {
 
-impl DefaultApi for DefaultApiClient {
-    fn dummy_get(&self, ) -> Result<(), Error<DummyGetError>> {
-        let configuration: &configuration::Configuration = self.configuration.borrow();
-        let client = &configuration.client;
+    let client = &configuration.client;
 
-        let uri_str = format!("{}/dummy", configuration.base_path);
-        let mut req_builder = client.get(uri_str.as_str());
+    let uri_str = format!("{}/dummy", configuration.base_path);
+    let mut req_builder = client.get(uri_str.as_str());
 
-        if let Some(ref user_agent) = configuration.user_agent {
-            req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
-        }
-
-        let req = req_builder.build()?;
-        let mut resp = client.execute(req)?;
-
-        let status = resp.status();
-        let content = resp.text()?;
-
-        if status.is_success() {
-            Ok(())
-        } else {
-            let entity: Option<DummyGetError> = serde_json::from_str(&content).ok();
-            let error = ResponseContent { status, content, entity };
-            Err(Error::ResponseError(error))
-        }
+    if let Some(ref user_agent) = configuration.user_agent {
+        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
 
+    let req = req_builder.build()?;
+    let mut resp = client.execute(req)?;
+
+    let status = resp.status();
+    let content = resp.text()?;
+
+    if status.is_success() {
+        Ok(())
+    } else {
+        let entity: Option<DummyGetError> = serde_json::from_str(&content).ok();
+        let error = ResponseContent { status, content, entity };
+        Err(Error::ResponseError(error))
+    }
 }
+

samples/client/petstore/rust/reqwest/rust-test/src/apis/mod.rs

@@ -40,5 +40,4 @@ pub fn urlencode<T: AsRef<str>>(s: T) -> String {
 
 pub mod default_api;
 
-pub mod client;
 pub mod configuration;