[Kotlin] [Retrofit2] [Coroutines] [Client] Option to remove Response<> wrapper in operation return types (#20613)

* Add useResponseAsReturnType option to kotlin, jvm-retrofit2 and coroutines api template (#15491)

* Add useResponseAsReturnType flag to kotlin-jvm-retrofit2-coroutines.yaml sample

* Generate sample

bin/configs/kotlin-jvm-retrofit2-coroutines.yaml

@@ -1,7 +1,7 @@
 generatorName: kotlin
-outputDir: samples/openapi3/client/petstore/kotlin-jvm-retrofit2-coroutines
+outputDir: samples/client/petstore/kotlin-jvm-retrofit2-coroutines
 library: jvm-retrofit2
-inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore-with-fake-endpoints-models-for-testing.yaml
+inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore.yaml
 templateDir: modules/openapi-generator/src/main/resources/kotlin-client
 additionalProperties:
   serializationLibrary: gson
@@ -9,3 +9,4 @@ additionalProperties:
   artifactId: kotlin-petstore-coroutines-client
   serializableModel: "true"
   dateLibrary: java8
+  useResponseAsReturnType: false

docs/generators/kotlin.md

@@ -30,7 +30,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |generateOneOfAnyOfWrappers|Generate oneOf, anyOf schemas as wrappers. Only `jvm-retrofit2`(library), `gson`(serializationLibrary) support this option.| |false|
 |generateRoomModels|Generate Android Room database models in addition to API models (JVM Volley library only)| |false|
 |groupId|Generated artifact package's organization (i.e. maven groupId).| |org.openapitools|
-|idea|Add IntellJ Idea plugin and mark Kotlin main and test folders as source folders.| |false|
+|idea|Add IntelliJ Idea plugin and mark Kotlin main and test folders as source folders.| |false|
 |library|Library template (sub-template) to use|<dl><dt>**jvm-ktor**</dt><dd>Platform: Java Virtual Machine. HTTP client: Ktor 1.6.7. JSON processing: Gson, Jackson (default).</dd><dt>**jvm-okhttp4**</dt><dd>[DEFAULT] Platform: Java Virtual Machine. HTTP client: OkHttp 4.2.0 (Android 5.0+ and Java 8+). JSON processing: Moshi 1.8.0.</dd><dt>**jvm-spring-webclient**</dt><dd>Platform: Java Virtual Machine. HTTP: Spring 5 (or 6 with useSpringBoot3 enabled) WebClient. JSON processing: Jackson.</dd><dt>**jvm-spring-restclient**</dt><dd>Platform: Java Virtual Machine. HTTP: Spring 6 RestClient. JSON processing: Jackson.</dd><dt>**jvm-retrofit2**</dt><dd>Platform: Java Virtual Machine. HTTP client: Retrofit 2.6.2.</dd><dt>**multiplatform**</dt><dd>Platform: Kotlin multiplatform. HTTP client: Ktor 1.6.7. JSON processing: Kotlinx Serialization: 1.2.1.</dd><dt>**jvm-volley**</dt><dd>Platform: JVM for Android. HTTP client: Volley 1.2.1. JSON processing: gson 2.8.9</dd><dt>**jvm-vertx**</dt><dd>Platform: Java Virtual Machine. HTTP client: Vert.x Web Client. JSON processing: Moshi, Gson or Jackson.</dd></dl>|jvm-okhttp4|
 |mapFileBinaryToByteArray|Map File and Binary to ByteArray (default: false)| |false|
 |modelMutable|Create mutable models| |false|
@@ -50,6 +50,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |supportAndroidApiLevel25AndBelow|[WARNING] This flag will generate code that has a known security vulnerability. It uses `kotlin.io.createTempFile` instead of `java.nio.file.Files.createTempFile` in order to support Android API level 25 and below. For more info, please check the following links https://github.com/OpenAPITools/openapi-generator/security/advisories/GHSA-23x4-m842-fmwf, https://github.com/OpenAPITools/openapi-generator/pull/9284| |false|
 |useCoroutines|Whether to use the Coroutines adapter with the retrofit2 library.| |false|
 |useNonAsciiHeaders|Allow to use non-ascii headers with the okhttp library| |false|
+|useResponseAsReturnType|When using retrofit2 and coroutines, use `Response`&lt;`T`&gt; as return type instead of `T`.| |true|
 |useRxJava3|Whether to use the RxJava3 adapter with the retrofit2 library.| |false|
 |useSettingsGradle|Whether the project uses settings.gradle.| |false|
 |useSpringBoot3|Whether to use the Spring Boot 3 with the jvm-spring-webclient library.| |false|

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

@@ -69,6 +69,7 @@ public class KotlinClientCodegen extends AbstractKotlinCodegen {
     public static final String USE_SETTINGS_GRADLE = "useSettingsGradle";
     public static final String IDEA = "idea";
     public static final String USE_SPRING_BOOT3 = "useSpringBoot3";
+    public static final String USE_RESPONSE_AS_RETURN_TYPE = "useResponseAsReturnType";
 
     public static final String DATE_LIBRARY = "dateLibrary";
     public static final String REQUEST_DATE_CONVERTER = "requestDateConverter";
@@ -251,7 +252,7 @@ public class KotlinClientCodegen extends AbstractKotlinCodegen {
         cliOptions.add(CliOption.newBoolean(OMIT_GRADLE_PLUGIN_VERSIONS, "Whether to declare Gradle plugin versions in build files."));
         cliOptions.add(CliOption.newBoolean(OMIT_GRADLE_WRAPPER, "Whether to omit Gradle wrapper for creating a sub project."));
         cliOptions.add(CliOption.newBoolean(USE_SETTINGS_GRADLE, "Whether the project uses settings.gradle."));
-        cliOptions.add(CliOption.newBoolean(IDEA, "Add IntellJ Idea plugin and mark Kotlin main and test folders as source folders."));
+        cliOptions.add(CliOption.newBoolean(IDEA, "Add IntelliJ Idea plugin and mark Kotlin main and test folders as source folders."));
 
         cliOptions.add(CliOption.newBoolean(MOSHI_CODE_GEN, "Whether to enable codegen with the Moshi library. Refer to the [official Moshi doc](https://github.com/square/moshi#codegen) for more info."));
         cliOptions.add(CliOption.newBoolean(FAIL_ON_UNKNOWN_PROPERTIES, "Fail Jackson de-serialization on unknown properties", false));
@@ -272,6 +273,7 @@ public class KotlinClientCodegen extends AbstractKotlinCodegen {
         cliOptions.add(serializationLibraryOpt.defaultValue(serializationLibrary.name()));
 
         cliOptions.add(CliOption.newBoolean(USE_NON_ASCII_HEADERS, "Allow to use non-ascii headers with the okhttp library"));
+        cliOptions.add(CliOption.newBoolean(USE_RESPONSE_AS_RETURN_TYPE, "When using retrofit2 and coroutines, use `Response`<`T`> as return type instead of `T`.", true));
     }
 
     @Override
@@ -615,12 +617,22 @@ public class KotlinClientCodegen extends AbstractKotlinCodegen {
     private void processJVMRetrofit2Library(String infrastructureFolder) {
         additionalProperties.put(JVM, true);
         additionalProperties.put(JVM_RETROFIT2, true);
+        setUseResponseAsReturnType();
         supportingFiles.add(new SupportingFile("infrastructure/ApiClient.kt.mustache", infrastructureFolder, "ApiClient.kt"));
         supportingFiles.add(new SupportingFile("infrastructure/ResponseExt.kt.mustache", infrastructureFolder, "ResponseExt.kt"));
         supportingFiles.add(new SupportingFile("infrastructure/CollectionFormats.kt.mustache", infrastructureFolder, "CollectionFormats.kt"));
         addSupportingSerializerAdapters(infrastructureFolder);
     }
 
+    private void setUseResponseAsReturnType() {
+        if (additionalProperties.containsKey(USE_RESPONSE_AS_RETURN_TYPE)) {
+            convertPropertyToBooleanAndWriteBack(USE_RESPONSE_AS_RETURN_TYPE);
+        } else {
+            // default is true for backward compatibility
+            additionalProperties.put(USE_RESPONSE_AS_RETURN_TYPE, true);
+        }
+    }
+
     private void processJVMVolleyLibrary(String infrastructureFolder, String requestFolder, String authFolder) {
 
         additionalProperties.put(JVM, true);

modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-retrofit2/api.mustache

@@ -155,7 +155,7 @@ import okhttp3.MultipartBody
     {{/prioritizedContentTypes}}
     {{/formParams}}
     @{{httpMethod}}("{{{path}}}")
-    {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}{{^doNotUseRxAndCoroutines}}{{#useCoroutines}}suspend {{/useCoroutines}}{{/doNotUseRxAndCoroutines}}fun {{operationId}}({{^allParams}}){{/allParams}}{{#allParams}}{{>queryParams}}{{>pathParams}}{{>headerParams}}{{>bodyParams}}{{>formParams}}{{^-last}}, {{/-last}}{{#-last}}){{/-last}}{{/allParams}}: {{^doNotUseRxAndCoroutines}}{{#useRxJava}}Observable<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{^returnType}}Unit{{/returnType}}{{/isResponseFile}}>{{/useRxJava}}{{#useRxJava2}}{{#returnType}}Single<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{/isResponseFile}}>{{/returnType}}{{^returnType}}Completable{{/returnType}}{{/useRxJava2}}{{#useRxJava3}}{{#returnType}}Single<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{/isResponseFile}}>{{/returnType}}{{^returnType}}Completable{{/returnType}}{{/useRxJava3}}{{#useCoroutines}}Response<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{^returnType}}Unit{{/returnType}}{{/isResponseFile}}>{{/useCoroutines}}{{/doNotUseRxAndCoroutines}}{{#doNotUseRxAndCoroutines}}Call<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{^returnType}}Unit{{/returnType}}{{/isResponseFile}}>{{/doNotUseRxAndCoroutines}}
+    {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}{{^doNotUseRxAndCoroutines}}{{#useCoroutines}}suspend {{/useCoroutines}}{{/doNotUseRxAndCoroutines}}fun {{operationId}}({{^allParams}}){{/allParams}}{{#allParams}}{{>queryParams}}{{>pathParams}}{{>headerParams}}{{>bodyParams}}{{>formParams}}{{^-last}}, {{/-last}}{{#-last}}){{/-last}}{{/allParams}}{{#returnType}}: {{/returnType}}{{^returnType}}{{#useResponseAsReturnType}}: {{/useResponseAsReturnType}}{{/returnType}}{{^doNotUseRxAndCoroutines}}{{#useRxJava}}Observable<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{^returnType}}Unit{{/returnType}}{{/isResponseFile}}>{{/useRxJava}}{{#useRxJava2}}{{#returnType}}Single<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{/isResponseFile}}>{{/returnType}}{{^returnType}}Completable{{/returnType}}{{/useRxJava2}}{{#useRxJava3}}{{#returnType}}Single<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{/isResponseFile}}>{{/returnType}}{{^returnType}}Completable{{/returnType}}{{/useRxJava3}}{{#useCoroutines}}{{#useResponseAsReturnType}}Response<{{/useResponseAsReturnType}}{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{^returnType}}{{#useResponseAsReturnType}}Unit{{/useResponseAsReturnType}}{{/returnType}}{{/isResponseFile}}{{#useResponseAsReturnType}}>{{/useResponseAsReturnType}}{{/useCoroutines}}{{/doNotUseRxAndCoroutines}}{{#doNotUseRxAndCoroutines}}Call<{{#isResponseFile}}ResponseBody{{/isResponseFile}}{{^isResponseFile}}{{{returnType}}}{{^returnType}}Unit{{/returnType}}{{/isResponseFile}}>{{/doNotUseRxAndCoroutines}}
 
     {{/operation}}
 }

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenApiTest.java

@@ -3,11 +3,13 @@ package org.openapitools.codegen.kotlin;
 import io.swagger.parser.OpenAPIParser;
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.parser.core.models.ParseOptions;
+import org.jetbrains.annotations.NotNull;
 import org.openapitools.codegen.ClientOptInput;
 import org.openapitools.codegen.CodegenConstants;
 import org.openapitools.codegen.DefaultGenerator;
 import org.openapitools.codegen.languages.KotlinClientCodegen;
 import org.openapitools.codegen.languages.features.CXFServerFeatures;
+import org.testng.Assert;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
@@ -15,6 +17,8 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.openapitools.codegen.TestUtils.assertFileContains;
 
@@ -37,23 +41,16 @@ public class KotlinClientCodegenApiTest {
     @Test(dataProvider = "clientLibraries")
     void testPathVariableIsNotEscaped_19930(ClientLibrary library) throws IOException {
 
-        OpenAPI openAPI = new OpenAPIParser()
+        OpenAPI openAPI = readOpenAPI("src/test/resources/3_0/kotlin/issue19930-path-escaping.json");
-                .readLocation("src/test/resources/3_0/kotlin/issue19930-path-escaping.json", null, new ParseOptions()).getOpenAPI();
 
         KotlinClientCodegen codegen = createCodegen(library);
 
         String outputPath = codegen.getOutputDir().replace('\\', '/');
-        ClientOptInput input = new ClientOptInput();
+        ClientOptInput input = createClientOptInput(openAPI, codegen);
-        input.openAPI(openAPI);
-        input.config(codegen);
 
         DefaultGenerator generator = new DefaultGenerator();
 
-        generator.setGeneratorPropertyDefault(CodegenConstants.MODELS, "false");
+        enableOnlyApiGeneration(generator);
-        generator.setGeneratorPropertyDefault(CodegenConstants.MODEL_TESTS, "false");
-        generator.setGeneratorPropertyDefault(CodegenConstants.MODEL_DOCS, "false");
-        generator.setGeneratorPropertyDefault(CodegenConstants.APIS, "true");
-        generator.setGeneratorPropertyDefault(CodegenConstants.SUPPORTING_FILES, "false");
 
         generator.opts(input).generate();
 
@@ -62,6 +59,65 @@ public class KotlinClientCodegenApiTest {
         assertFileContains(Paths.get(outputPath + "/src/" + library.getSourceRoot() + "/org/openapitools/client/apis/ArticleApi.kt"), "article('{Id}')");
     }
 
+    @DataProvider(name = "useResponseAsReturnType")
+    public static Object[][] useResponseAsReturnTypeTestData() {
+        return new Object[][]{
+                {null, "Response<Pet>", ": Response<Unit>"},
+                {true, "Response<Pet>", ": Response<Unit>"},
+                {false, "Pet", ""},
+                {"false", "Pet", ""}};
+    }
+
+    @Test(dataProvider = "useResponseAsReturnType")
+    public void testUseResponseAsReturnType(Object useResponseAsReturnType, String expectedResponse, String expectedUnitResponse) throws IOException {
+        OpenAPI openAPI = readOpenAPI("3_0/kotlin/petstore.yaml");
+
+        KotlinClientCodegen codegen = createCodegen(ClientLibrary.JVM_RETROFIT2);
+        codegen.additionalProperties().put(KotlinClientCodegen.USE_COROUTINES, "true");
+        if (useResponseAsReturnType != null) {
+            codegen.additionalProperties().put(KotlinClientCodegen.USE_RESPONSE_AS_RETURN_TYPE, useResponseAsReturnType);
+        }
+
+        ClientOptInput input = createClientOptInput(openAPI, codegen);
+
+        DefaultGenerator generator = new DefaultGenerator();
+
+        enableOnlyApiGeneration(generator);
+
+        List<File> files = generator.opts(input).generate();
+        File petApi = files.stream().filter(file -> file.getName().equals("PetApi.kt")).findAny().orElseThrow();
+        List<String> lines = Files.readAllLines(petApi.toPath()).stream().map(String::trim).collect(Collectors.toList());
+        assertFileContainsLine(lines, "suspend fun addPet(@Body pet: Pet): " + expectedResponse);
+        assertFileContainsLine(lines, "suspend fun deletePet(@Path(\"petId\") petId: kotlin.Long, @Header(\"api_key\") apiKey: kotlin.String? = null)" + expectedUnitResponse);
+    }
+
+    private static void assertFileContainsLine(List<String> lines, String line) {
+        Assert.assertListContains(lines, s -> s.equals(line), line);
+    }
+
+    private static void enableOnlyApiGeneration(DefaultGenerator generator) {
+        generator.setGeneratorPropertyDefault(CodegenConstants.MODELS, "false");
+        generator.setGeneratorPropertyDefault(CodegenConstants.MODEL_TESTS, "false");
+        generator.setGeneratorPropertyDefault(CodegenConstants.MODEL_DOCS, "false");
+        generator.setGeneratorPropertyDefault(CodegenConstants.APIS, "true");
+        generator.setGeneratorPropertyDefault(CodegenConstants.SUPPORTING_FILES, "false");
+        generator.setGeneratorPropertyDefault(CodegenConstants.API_TESTS, "false");
+        generator.setGeneratorPropertyDefault(CodegenConstants.API_DOCS, "false");
+    }
+
+    @NotNull
+    private static ClientOptInput createClientOptInput(OpenAPI openAPI, KotlinClientCodegen codegen) {
+        ClientOptInput input = new ClientOptInput();
+        input.openAPI(openAPI);
+        input.config(codegen);
+        return input;
+    }
+
+    private static OpenAPI readOpenAPI(String url) {
+        return new OpenAPIParser()
+                .readLocation(url, null, new ParseOptions()).getOpenAPI();
+    }
+
     private KotlinClientCodegen createCodegen(ClientLibrary library) throws IOException {
         File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
         output.deleteOnExit();

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/.openapi-generator/FILES

@@ -0,0 +1,37 @@
+README.md
+build.gradle
+docs/ApiResponse.md
+docs/Category.md
+docs/Order.md
+docs/Pet.md
+docs/PetApi.md
+docs/StoreApi.md
+docs/Tag.md
+docs/User.md
+docs/UserApi.md
+gradle/wrapper/gradle-wrapper.jar
+gradle/wrapper/gradle-wrapper.properties
+gradlew
+gradlew.bat
+settings.gradle
+src/main/kotlin/org/openapitools/client/apis/PetApi.kt
+src/main/kotlin/org/openapitools/client/apis/StoreApi.kt
+src/main/kotlin/org/openapitools/client/apis/UserApi.kt
+src/main/kotlin/org/openapitools/client/auth/ApiKeyAuth.kt
+src/main/kotlin/org/openapitools/client/auth/OAuth.kt
+src/main/kotlin/org/openapitools/client/auth/OAuthFlow.kt
+src/main/kotlin/org/openapitools/client/auth/OAuthOkHttpClient.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ByteArrayAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/CollectionFormats.kt
+src/main/kotlin/org/openapitools/client/infrastructure/LocalDateAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/LocalDateTimeAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/OffsetDateTimeAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ResponseExt.kt
+src/main/kotlin/org/openapitools/client/infrastructure/Serializer.kt
+src/main/kotlin/org/openapitools/client/models/Category.kt
+src/main/kotlin/org/openapitools/client/models/ModelApiResponse.kt
+src/main/kotlin/org/openapitools/client/models/Order.kt
+src/main/kotlin/org/openapitools/client/models/Pet.kt
+src/main/kotlin/org/openapitools/client/models/Tag.kt
+src/main/kotlin/org/openapitools/client/models/User.kt

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.13.0-SNAPSHOT

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/README.md

@@ -0,0 +1,102 @@
+# org.openapitools.client - Kotlin client library for OpenAPI Petstore
+
+This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+
+## Overview
+This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project.  By using the [openapi-spec](https://github.com/OAI/OpenAPI-Specification) from a remote server, you can easily generate an API client.
+
+- API version: 1.0.0
+- Package version: 
+- Generator version: 7.13.0-SNAPSHOT
+- Build package: org.openapitools.codegen.languages.KotlinClientCodegen
+
+## Requires
+
+* Kotlin 1.7.21
+* Gradle 7.5
+
+## Build
+
+First, create the gradle wrapper script:
+
+```
+gradle wrapper
+```
+
+Then, run:
+
+```
+./gradlew check assemble
+```
+
+This runs all tests and packages the library.
+
+## Features/Implementation Notes
+
+* Supports JSON inputs/outputs, File inputs, and Form inputs.
+* Supports collection formats for query parameters: csv, tsv, ssv, pipes.
+* Some Kotlin and Java types are fully qualified to avoid conflicts with types defined in OpenAPI definitions.
+* Implementation of ApiClient is intended to reduce method counts, specifically to benefit Android targets.
+
+<a id="documentation-for-api-endpoints"></a>
+## Documentation for API Endpoints
+
+All URIs are relative to *http://petstore.swagger.io/v2*
+
+| Class | Method | HTTP request | Description |
+| ------------ | ------------- | ------------- | ------------- |
+| *PetApi* | [**addPet**](docs/PetApi.md#addpet) | **POST** pet | Add a new pet to the store |
+| *PetApi* | [**deletePet**](docs/PetApi.md#deletepet) | **DELETE** pet/{petId} | Deletes a pet |
+| *PetApi* | [**findPetsByStatus**](docs/PetApi.md#findpetsbystatus) | **GET** pet/findByStatus | Finds Pets by status |
+| *PetApi* | [**findPetsByTags**](docs/PetApi.md#findpetsbytags) | **GET** pet/findByTags | Finds Pets by tags |
+| *PetApi* | [**getPetById**](docs/PetApi.md#getpetbyid) | **GET** pet/{petId} | Find pet by ID |
+| *PetApi* | [**updatePet**](docs/PetApi.md#updatepet) | **PUT** pet | Update an existing pet |
+| *PetApi* | [**updatePetWithForm**](docs/PetApi.md#updatepetwithform) | **POST** pet/{petId} | Updates a pet in the store with form data |
+| *PetApi* | [**uploadFile**](docs/PetApi.md#uploadfile) | **POST** pet/{petId}/uploadImage | uploads an image |
+| *StoreApi* | [**deleteOrder**](docs/StoreApi.md#deleteorder) | **DELETE** store/order/{orderId} | Delete purchase order by ID |
+| *StoreApi* | [**getInventory**](docs/StoreApi.md#getinventory) | **GET** store/inventory | Returns pet inventories by status |
+| *StoreApi* | [**getOrderById**](docs/StoreApi.md#getorderbyid) | **GET** store/order/{orderId} | Find purchase order by ID |
+| *StoreApi* | [**placeOrder**](docs/StoreApi.md#placeorder) | **POST** store/order | Place an order for a pet |
+| *UserApi* | [**createUser**](docs/UserApi.md#createuser) | **POST** user | Create user |
+| *UserApi* | [**createUsersWithArrayInput**](docs/UserApi.md#createuserswitharrayinput) | **POST** user/createWithArray | Creates list of users with given input array |
+| *UserApi* | [**createUsersWithListInput**](docs/UserApi.md#createuserswithlistinput) | **POST** user/createWithList | Creates list of users with given input array |
+| *UserApi* | [**deleteUser**](docs/UserApi.md#deleteuser) | **DELETE** user/{username} | Delete user |
+| *UserApi* | [**getUserByName**](docs/UserApi.md#getuserbyname) | **GET** user/{username} | Get user by user name |
+| *UserApi* | [**loginUser**](docs/UserApi.md#loginuser) | **GET** user/login | Logs user into the system |
+| *UserApi* | [**logoutUser**](docs/UserApi.md#logoutuser) | **GET** user/logout | Logs out current logged in user session |
+| *UserApi* | [**updateUser**](docs/UserApi.md#updateuser) | **PUT** user/{username} | Updated user |
+
+
+<a id="documentation-for-models"></a>
+## Documentation for Models
+
+ - [org.openapitools.client.models.Category](docs/Category.md)
+ - [org.openapitools.client.models.ModelApiResponse](docs/ModelApiResponse.md)
+ - [org.openapitools.client.models.Order](docs/Order.md)
+ - [org.openapitools.client.models.Pet](docs/Pet.md)
+ - [org.openapitools.client.models.Tag](docs/Tag.md)
+ - [org.openapitools.client.models.User](docs/User.md)
+
+
+<a id="documentation-for-authorization"></a>
+## Documentation for Authorization
+
+
+Authentication schemes defined for the API:
+<a id="petstore_auth"></a>
+### petstore_auth
+
+- **Type**: OAuth
+- **Flow**: implicit
+- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog
+- **Scopes**: 
+  - write:pets: modify pets in your account
+  - read:pets: read your pets
+
+<a id="api_key"></a>
+### api_key
+
+- **Type**: API key
+- **API key parameter name**: api_key
+- **Location**: HTTP header
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/build.gradle

@@ -0,0 +1,66 @@
+group 'org.openapitools'
+version '1.0.0'
+
+wrapper {
+    gradleVersion = '8.7'
+    distributionUrl = "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip"
+}
+
+buildscript {
+    ext.kotlin_version = '1.9.23'
+    ext.retrofitVersion = '2.10.0'
+    ext.spotless_version = "6.25.0"
+
+    repositories {
+        maven { url "https://repo1.maven.org/maven2" }
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:$spotless_version"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'maven-publish'
+apply plugin: 'com.diffplug.spotless'
+
+repositories {
+    maven { url "https://repo1.maven.org/maven2" }
+}
+
+// Use spotless plugin to automatically format code, remove unused import, etc
+// To apply changes directly to the file, run `gradlew spotlessApply`
+// Ref: https://github.com/diffplug/spotless/tree/main/plugin-gradle
+spotless {
+    // comment out below to run spotless as part of the `check` task
+    enforceCheck false
+
+    format 'misc', {
+        // define the files (e.g. '*.gradle', '*.md') to apply `misc` to
+        target '.gitignore'
+
+        // define the steps to apply to those files
+        trimTrailingWhitespace()
+        indentWithSpaces() // Takes an integer argument if you don't like 4
+        endWithNewline()
+    }
+    kotlin {
+        ktfmt()
+    }
+}
+
+test {
+    useJUnitPlatform()
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0"
+    implementation "com.google.code.gson:gson:2.10.1"
+    implementation "org.apache.oltu.oauth2:org.apache.oltu.oauth2.client:1.0.2"
+    implementation "com.squareup.okhttp3:logging-interceptor:4.12.0"
+    implementation "com.squareup.retrofit2:retrofit:$retrofitVersion"
+    implementation "com.squareup.retrofit2:converter-gson:$retrofitVersion"
+    implementation "com.squareup.retrofit2:converter-scalars:$retrofitVersion"
+    testImplementation "io.kotlintest:kotlintest-runner-junit5:3.4.2"
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/ApiResponse.md

@@ -0,0 +1,12 @@
+
+# ModelApiResponse
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **code** | **kotlin.Int** |  |  [optional] |
+| **type** | **kotlin.String** |  |  [optional] |
+| **message** | **kotlin.String** |  |  [optional] |
+
+
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/Category.md

@@ -0,0 +1,11 @@
+
+# Category
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **id** | **kotlin.Long** |  |  [optional] |
+| **name** | **kotlin.String** |  |  [optional] |
+
+
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/Order.md

@@ -0,0 +1,22 @@
+
+# Order
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **id** | **kotlin.Long** |  |  [optional] |
+| **petId** | **kotlin.Long** |  |  [optional] |
+| **quantity** | **kotlin.Int** |  |  [optional] |
+| **shipDate** | [**java.time.OffsetDateTime**](java.time.OffsetDateTime.md) |  |  [optional] |
+| **status** | [**inline**](#Status) | Order Status |  [optional] |
+| **complete** | **kotlin.Boolean** |  |  [optional] |
+
+
+<a id="Status"></a>
+## Enum: status
+| Name | Value |
+| ---- | ----- |
+| status | placed, approved, delivered |
+
+
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/Pet.md

@@ -0,0 +1,22 @@
+
+# Pet
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **name** | **kotlin.String** |  |  |
+| **photoUrls** | **kotlin.collections.List<kotlin.String>** |  |  |
+| **id** | **kotlin.Long** |  |  [optional] |
+| **category** | [**Category**](Category.md) |  |  [optional] |
+| **tags** | [**kotlin.collections.List<Tag>**](Tag.md) |  |  [optional] |
+| **status** | [**inline**](#Status) | pet status in the store |  [optional] |
+
+
+<a id="Status"></a>
+## Enum: status
+| Name | Value |
+| ---- | ----- |
+| status | available, pending, sold |
+
+
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/PetApi.md

@@ -0,0 +1,338 @@
+# PetApi
+
+All URIs are relative to *http://petstore.swagger.io/v2*
+
+| Method | HTTP request | Description |
+| ------------- | ------------- | ------------- |
+| [**addPet**](PetApi.md#addPet) | **POST** pet | Add a new pet to the store |
+| [**deletePet**](PetApi.md#deletePet) | **DELETE** pet/{petId} | Deletes a pet |
+| [**findPetsByStatus**](PetApi.md#findPetsByStatus) | **GET** pet/findByStatus | Finds Pets by status |
+| [**findPetsByTags**](PetApi.md#findPetsByTags) | **GET** pet/findByTags | Finds Pets by tags |
+| [**getPetById**](PetApi.md#getPetById) | **GET** pet/{petId} | Find pet by ID |
+| [**updatePet**](PetApi.md#updatePet) | **PUT** pet | Update an existing pet |
+| [**updatePetWithForm**](PetApi.md#updatePetWithForm) | **POST** pet/{petId} | Updates a pet in the store with form data |
+| [**uploadFile**](PetApi.md#uploadFile) | **POST** pet/{petId}/uploadImage | uploads an image |
+
+
+
+Add a new pet to the store
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val pet : Pet =  // Pet | Pet object that needs to be added to the store
+
+launch(Dispatchers.IO) {
+    val result : Pet = webService.addPet(pet)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **pet** | [**Pet**](Pet.md)| Pet object that needs to be added to the store | |
+
+### Return type
+
+[**Pet**](Pet.md)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/json, application/xml
+ - **Accept**: application/xml, application/json
+
+
+Deletes a pet
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val petId : kotlin.Long = 789 // kotlin.Long | Pet id to delete
+val apiKey : kotlin.String = apiKey_example // kotlin.String | 
+
+launch(Dispatchers.IO) {
+    webService.deletePet(petId, apiKey)
+}
+```
+
+### Parameters
+| **petId** | **kotlin.Long**| Pet id to delete | |
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **apiKey** | **kotlin.String**|  | [optional] |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+Finds Pets by status
+
+Multiple status values can be provided with comma separated strings
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val status : kotlin.collections.List<kotlin.String> =  // kotlin.collections.List<kotlin.String> | Status values that need to be considered for filter
+
+launch(Dispatchers.IO) {
+    val result : kotlin.collections.List<Pet> = webService.findPetsByStatus(status)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **status** | [**kotlin.collections.List&lt;kotlin.String&gt;**](kotlin.String.md)| Status values that need to be considered for filter | [enum: available, pending, sold] |
+
+### Return type
+
+[**kotlin.collections.List&lt;Pet&gt;**](Pet.md)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+Finds Pets by tags
+
+Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val tags : kotlin.collections.List<kotlin.String> =  // kotlin.collections.List<kotlin.String> | Tags to filter by
+
+launch(Dispatchers.IO) {
+    val result : kotlin.collections.List<Pet> = webService.findPetsByTags(tags)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **tags** | [**kotlin.collections.List&lt;kotlin.String&gt;**](kotlin.String.md)| Tags to filter by | |
+
+### Return type
+
+[**kotlin.collections.List&lt;Pet&gt;**](Pet.md)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+Find pet by ID
+
+Returns a single pet
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to return
+
+launch(Dispatchers.IO) {
+    val result : Pet = webService.getPetById(petId)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **petId** | **kotlin.Long**| ID of pet to return | |
+
+### Return type
+
+[**Pet**](Pet.md)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+Update an existing pet
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val pet : Pet =  // Pet | Pet object that needs to be added to the store
+
+launch(Dispatchers.IO) {
+    val result : Pet = webService.updatePet(pet)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **pet** | [**Pet**](Pet.md)| Pet object that needs to be added to the store | |
+
+### Return type
+
+[**Pet**](Pet.md)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/json, application/xml
+ - **Accept**: application/xml, application/json
+
+
+Updates a pet in the store with form data
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val petId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be updated
+val name : kotlin.String = name_example // kotlin.String | Updated name of the pet
+val status : kotlin.String = status_example // kotlin.String | Updated status of the pet
+
+launch(Dispatchers.IO) {
+    webService.updatePetWithForm(petId, name, status)
+}
+```
+
+### Parameters
+| **petId** | **kotlin.Long**| ID of pet that needs to be updated | |
+| **name** | **kotlin.String**| Updated name of the pet | [optional] |
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **status** | **kotlin.String**| Updated status of the pet | [optional] |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/x-www-form-urlencoded
+ - **Accept**: Not defined
+
+
+uploads an image
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(PetApi::class.java)
+val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to update
+val additionalMetadata : kotlin.String = additionalMetadata_example // kotlin.String | Additional data to pass to server
+val file : java.io.File = BINARY_DATA_HERE // java.io.File | file to upload
+
+launch(Dispatchers.IO) {
+    val result : ModelApiResponse = webService.uploadFile(petId, additionalMetadata, file)
+}
+```
+
+### Parameters
+| **petId** | **kotlin.Long**| ID of pet to update | |
+| **additionalMetadata** | **kotlin.String**| Additional data to pass to server | [optional] |
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **file** | **java.io.File**| file to upload | [optional] |
+
+### Return type
+
+[**ModelApiResponse**](ModelApiResponse.md)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: multipart/form-data
+ - **Accept**: application/json
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/StoreApi.md

@@ -0,0 +1,165 @@
+# StoreApi
+
+All URIs are relative to *http://petstore.swagger.io/v2*
+
+| Method | HTTP request | Description |
+| ------------- | ------------- | ------------- |
+| [**deleteOrder**](StoreApi.md#deleteOrder) | **DELETE** store/order/{orderId} | Delete purchase order by ID |
+| [**getInventory**](StoreApi.md#getInventory) | **GET** store/inventory | Returns pet inventories by status |
+| [**getOrderById**](StoreApi.md#getOrderById) | **GET** store/order/{orderId} | Find purchase order by ID |
+| [**placeOrder**](StoreApi.md#placeOrder) | **POST** store/order | Place an order for a pet |
+
+
+
+Delete purchase order by ID
+
+For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(StoreApi::class.java)
+val orderId : kotlin.String = orderId_example // kotlin.String | ID of the order that needs to be deleted
+
+launch(Dispatchers.IO) {
+    webService.deleteOrder(orderId)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **orderId** | **kotlin.String**| ID of the order that needs to be deleted | |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+Returns pet inventories by status
+
+Returns a map of status codes to quantities
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(StoreApi::class.java)
+
+launch(Dispatchers.IO) {
+    val result : kotlin.collections.Map<kotlin.String, kotlin.Int> = webService.getInventory()
+}
+```
+
+### Parameters
+This endpoint does not need any parameter.
+
+### Return type
+
+**kotlin.collections.Map&lt;kotlin.String, kotlin.Int&gt;**
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+
+Find purchase order by ID
+
+For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generate exceptions
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(StoreApi::class.java)
+val orderId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be fetched
+
+launch(Dispatchers.IO) {
+    val result : Order = webService.getOrderById(orderId)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **orderId** | **kotlin.Long**| ID of pet that needs to be fetched | |
+
+### Return type
+
+[**Order**](Order.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+Place an order for a pet
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(StoreApi::class.java)
+val order : Order =  // Order | order placed for purchasing the pet
+
+launch(Dispatchers.IO) {
+    val result : Order = webService.placeOrder(order)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **order** | [**Order**](Order.md)| order placed for purchasing the pet | |
+
+### Return type
+
+[**Order**](Order.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/xml, application/json
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/Tag.md

@@ -0,0 +1,11 @@
+
+# Tag
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **id** | **kotlin.Long** |  |  [optional] |
+| **name** | **kotlin.String** |  |  [optional] |
+
+
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/User.md

@@ -0,0 +1,17 @@
+
+# User
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **id** | **kotlin.Long** |  |  [optional] |
+| **username** | **kotlin.String** |  |  [optional] |
+| **firstName** | **kotlin.String** |  |  [optional] |
+| **lastName** | **kotlin.String** |  |  [optional] |
+| **email** | **kotlin.String** |  |  [optional] |
+| **password** | **kotlin.String** |  |  [optional] |
+| **phone** | **kotlin.String** |  |  [optional] |
+| **userStatus** | **kotlin.Int** | User Status |  [optional] |
+
+
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/docs/UserApi.md

@@ -0,0 +1,329 @@
+# UserApi
+
+All URIs are relative to *http://petstore.swagger.io/v2*
+
+| Method | HTTP request | Description |
+| ------------- | ------------- | ------------- |
+| [**createUser**](UserApi.md#createUser) | **POST** user | Create user |
+| [**createUsersWithArrayInput**](UserApi.md#createUsersWithArrayInput) | **POST** user/createWithArray | Creates list of users with given input array |
+| [**createUsersWithListInput**](UserApi.md#createUsersWithListInput) | **POST** user/createWithList | Creates list of users with given input array |
+| [**deleteUser**](UserApi.md#deleteUser) | **DELETE** user/{username} | Delete user |
+| [**getUserByName**](UserApi.md#getUserByName) | **GET** user/{username} | Get user by user name |
+| [**loginUser**](UserApi.md#loginUser) | **GET** user/login | Logs user into the system |
+| [**logoutUser**](UserApi.md#logoutUser) | **GET** user/logout | Logs out current logged in user session |
+| [**updateUser**](UserApi.md#updateUser) | **PUT** user/{username} | Updated user |
+
+
+
+Create user
+
+This can only be done by the logged in user.
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val user : User =  // User | Created user object
+
+launch(Dispatchers.IO) {
+    webService.createUser(user)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **user** | [**User**](User.md)| Created user object | |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+
+
+Creates list of users with given input array
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val user : kotlin.collections.List<User> =  // kotlin.collections.List<User> | List of user object
+
+launch(Dispatchers.IO) {
+    webService.createUsersWithArrayInput(user)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **user** | [**kotlin.collections.List&lt;User&gt;**](User.md)| List of user object | |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+
+
+Creates list of users with given input array
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val user : kotlin.collections.List<User> =  // kotlin.collections.List<User> | List of user object
+
+launch(Dispatchers.IO) {
+    webService.createUsersWithListInput(user)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **user** | [**kotlin.collections.List&lt;User&gt;**](User.md)| List of user object | |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+
+
+Delete user
+
+This can only be done by the logged in user.
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val username : kotlin.String = username_example // kotlin.String | The name that needs to be deleted
+
+launch(Dispatchers.IO) {
+    webService.deleteUser(username)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **username** | **kotlin.String**| The name that needs to be deleted | |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+Get user by user name
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val username : kotlin.String = username_example // kotlin.String | The name that needs to be fetched. Use user1 for testing.
+
+launch(Dispatchers.IO) {
+    val result : User = webService.getUserByName(username)
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **username** | **kotlin.String**| The name that needs to be fetched. Use user1 for testing. | |
+
+### Return type
+
+[**User**](User.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+Logs user into the system
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val username : kotlin.String = username_example // kotlin.String | The user name for login
+val password : kotlin.String = password_example // kotlin.String | The password for login in clear text
+
+launch(Dispatchers.IO) {
+    val result : kotlin.String = webService.loginUser(username, password)
+}
+```
+
+### Parameters
+| **username** | **kotlin.String**| The user name for login | |
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **password** | **kotlin.String**| The password for login in clear text | |
+
+### Return type
+
+**kotlin.String**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/xml, application/json
+
+
+Logs out current logged in user session
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+
+launch(Dispatchers.IO) {
+    webService.logoutUser()
+}
+```
+
+### Parameters
+This endpoint does not need any parameter.
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+
+Updated user
+
+This can only be done by the logged in user.
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.*
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiClient = ApiClient()
+val webService = apiClient.createWebservice(UserApi::class.java)
+val username : kotlin.String = username_example // kotlin.String | name that need to be deleted
+val user : User =  // User | Updated user object
+
+launch(Dispatchers.IO) {
+    webService.updateUser(username, user)
+}
+```
+
+### Parameters
+| **username** | **kotlin.String**| name that need to be deleted | |
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **user** | [**User**](User.md)| Updated user object | |
+
+### Return type
+
+null (empty response body)
+
+### Authorization
+
+
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: Not defined
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-all.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/gradlew

@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+[ -h "$app_path" ]
+do
+ls=$( ls -ld "$app_path" )
+link=${ls#*' -> '}
+case $link in             #(
+/*)   app_path=$link ;; #(
+*)    app_path=$APP_HOME$link ;;
+esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+echo "$*"
+} >&2
+
+die () {
+echo
+echo "$*"
+echo
+exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+CYGWIN* )         cygwin=true  ;; #(
+Darwin* )         darwin=true  ;; #(
+MSYS* | MINGW* )  msys=true    ;; #(
+NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+# IBM's JDK on AIX uses strange locations for the executables
+JAVACMD=$JAVA_HOME/jre/sh/java
+else
+JAVACMD=$JAVA_HOME/bin/java
+fi
+if [ ! -x "$JAVACMD" ] ; then
+die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+else
+JAVACMD=java
+if ! command -v java >/dev/null 2>&1
+then
+die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+case $MAX_FD in #(
+max*)
+# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+# shellcheck disable=SC2039,SC3045
+MAX_FD=$( ulimit -H -n ) ||
+warn "Could not query maximum file descriptor limit"
+esac
+case $MAX_FD in  #(
+'' | soft) :;; #(
+*)
+# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+# shellcheck disable=SC2039,SC3045
+ulimit -n "$MAX_FD" ||
+warn "Could not set maximum file descriptor limit to $MAX_FD"
+esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+# Now convert the arguments - kludge to limit ourselves to /bin/sh
+for arg do
+if
+case $arg in                                #(
+-*)   false ;;                            # don't mess with options #(
+/?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+[ -e "$t" ] ;;                      #(
+*)    false ;;
+esac
+then
+arg=$( cygpath --path --ignore --mixed "$arg" )
+fi
+# Roll the args list around exactly as many times as the number of
+# args, so each arg winds up back in the position where it started, but
+# possibly modified.
+#
+# NB: a `for` loop captures its iteration list before it begins, so
+# changing the positional parameters here affects neither the number of
+# iterations, nor the values presented in `arg`.
+shift                   # remove old arg
+set -- "$@" "$arg"      # push replacement arg
+done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+"-Dorg.gradle.appname=$APP_BASE_NAME" \
+-classpath "$CLASSPATH" \
+org.gradle.wrapper.GradleWrapperMain \
+"$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+xargs -n1 |
+sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+tr '\n' ' '
+)" '"$@"'
+
+exec "$JAVACMD" "$@"

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'kotlin-petstore-coroutines-client'

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/apis/PetApi.kt

@@ -0,0 +1,145 @@
+package org.openapitools.client.apis
+
+import org.openapitools.client.infrastructure.CollectionFormats.*
+import retrofit2.http.*
+import retrofit2.Response
+import okhttp3.RequestBody
+import com.google.gson.annotations.SerializedName
+
+import org.openapitools.client.models.ModelApiResponse
+import org.openapitools.client.models.Pet
+
+import okhttp3.MultipartBody
+
+interface PetApi {
+    /**
+     * POST pet
+     * Add a new pet to the store
+     * 
+     * Responses:
+     *  - 200: successful operation
+     *  - 405: Invalid input
+     *
+     * @param pet Pet object that needs to be added to the store
+     * @return [Pet]
+     */
+    @POST("pet")
+    suspend fun addPet(@Body pet: Pet): Pet
+
+    /**
+     * DELETE pet/{petId}
+     * Deletes a pet
+     * 
+     * Responses:
+     *  - 400: Invalid pet value
+     *
+     * @param petId Pet id to delete
+     * @param apiKey  (optional)
+     * @return [Unit]
+     */
+    @DELETE("pet/{petId}")
+    suspend fun deletePet(@Path("petId") petId: kotlin.Long, @Header("api_key") apiKey: kotlin.String? = null)
+
+
+    /**
+    * enum for parameter status
+    */
+    enum class StatusFindPetsByStatus(val value: kotlin.String) {
+        @SerializedName(value = "available") available("available"),
+        @SerializedName(value = "pending") pending("pending"),
+        @SerializedName(value = "sold") sold("sold")
+    }
+
+    /**
+     * GET pet/findByStatus
+     * Finds Pets by status
+     * Multiple status values can be provided with comma separated strings
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid status value
+     *
+     * @param status Status values that need to be considered for filter
+     * @return [kotlin.collections.List<Pet>]
+     */
+    @GET("pet/findByStatus")
+    suspend fun findPetsByStatus(@Query("status") status: CSVParams): kotlin.collections.List<Pet>
+
+    /**
+     * GET pet/findByTags
+     * Finds Pets by tags
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid tag value
+     *
+     * @param tags Tags to filter by
+     * @return [kotlin.collections.List<Pet>]
+     */
+    @Deprecated("This api was deprecated")
+    @GET("pet/findByTags")
+    suspend fun findPetsByTags(@Query("tags") tags: CSVParams): kotlin.collections.List<Pet>
+
+    /**
+     * GET pet/{petId}
+     * Find pet by ID
+     * Returns a single pet
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid ID supplied
+     *  - 404: Pet not found
+     *
+     * @param petId ID of pet to return
+     * @return [Pet]
+     */
+    @GET("pet/{petId}")
+    suspend fun getPetById(@Path("petId") petId: kotlin.Long): Pet
+
+    /**
+     * PUT pet
+     * Update an existing pet
+     * 
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid ID supplied
+     *  - 404: Pet not found
+     *  - 405: Validation exception
+     *
+     * @param pet Pet object that needs to be added to the store
+     * @return [Pet]
+     */
+    @PUT("pet")
+    suspend fun updatePet(@Body pet: Pet): Pet
+
+    /**
+     * POST pet/{petId}
+     * Updates a pet in the store with form data
+     * 
+     * Responses:
+     *  - 405: Invalid input
+     *
+     * @param petId ID of pet that needs to be updated
+     * @param name Updated name of the pet (optional)
+     * @param status Updated status of the pet (optional)
+     * @return [Unit]
+     */
+    @FormUrlEncoded
+    @POST("pet/{petId}")
+    suspend fun updatePetWithForm(@Path("petId") petId: kotlin.Long, @Field("name") name: kotlin.String? = null, @Field("status") status: kotlin.String? = null)
+
+    /**
+     * POST pet/{petId}/uploadImage
+     * uploads an image
+     * 
+     * Responses:
+     *  - 200: successful operation
+     *
+     * @param petId ID of pet to update
+     * @param additionalMetadata Additional data to pass to server (optional)
+     * @param file file to upload (optional)
+     * @return [ModelApiResponse]
+     */
+    @Multipart
+    @POST("pet/{petId}/uploadImage")
+    suspend fun uploadFile(@Path("petId") petId: kotlin.Long, @Part("additionalMetadata") additionalMetadata: kotlin.String? = null, @Part file: MultipartBody.Part? = null): ModelApiResponse
+
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/apis/StoreApi.kt

@@ -0,0 +1,67 @@
+package org.openapitools.client.apis
+
+import org.openapitools.client.infrastructure.CollectionFormats.*
+import retrofit2.http.*
+import retrofit2.Response
+import okhttp3.RequestBody
+import com.google.gson.annotations.SerializedName
+
+import org.openapitools.client.models.Order
+
+interface StoreApi {
+    /**
+     * DELETE store/order/{orderId}
+     * Delete purchase order by ID
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     * Responses:
+     *  - 400: Invalid ID supplied
+     *  - 404: Order not found
+     *
+     * @param orderId ID of the order that needs to be deleted
+     * @return [Unit]
+     */
+    @DELETE("store/order/{orderId}")
+    suspend fun deleteOrder(@Path("orderId") orderId: kotlin.String)
+
+    /**
+     * GET store/inventory
+     * Returns pet inventories by status
+     * Returns a map of status codes to quantities
+     * Responses:
+     *  - 200: successful operation
+     *
+     * @return [kotlin.collections.Map<kotlin.String, kotlin.Int>]
+     */
+    @GET("store/inventory")
+    suspend fun getInventory(): kotlin.collections.Map<kotlin.String, kotlin.Int>
+
+    /**
+     * GET store/order/{orderId}
+     * Find purchase order by ID
+     * For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generate exceptions
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid ID supplied
+     *  - 404: Order not found
+     *
+     * @param orderId ID of pet that needs to be fetched
+     * @return [Order]
+     */
+    @GET("store/order/{orderId}")
+    suspend fun getOrderById(@Path("orderId") orderId: kotlin.Long): Order
+
+    /**
+     * POST store/order
+     * Place an order for a pet
+     * 
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid Order
+     *
+     * @param order order placed for purchasing the pet
+     * @return [Order]
+     */
+    @POST("store/order")
+    suspend fun placeOrder(@Body order: Order): Order
+
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/apis/UserApi.kt

@@ -0,0 +1,122 @@
+package org.openapitools.client.apis
+
+import org.openapitools.client.infrastructure.CollectionFormats.*
+import retrofit2.http.*
+import retrofit2.Response
+import okhttp3.RequestBody
+import com.google.gson.annotations.SerializedName
+
+import org.openapitools.client.models.User
+
+interface UserApi {
+    /**
+     * POST user
+     * Create user
+     * This can only be done by the logged in user.
+     * Responses:
+     *  - 0: successful operation
+     *
+     * @param user Created user object
+     * @return [Unit]
+     */
+    @POST("user")
+    suspend fun createUser(@Body user: User)
+
+    /**
+     * POST user/createWithArray
+     * Creates list of users with given input array
+     * 
+     * Responses:
+     *  - 0: successful operation
+     *
+     * @param user List of user object
+     * @return [Unit]
+     */
+    @POST("user/createWithArray")
+    suspend fun createUsersWithArrayInput(@Body user: kotlin.collections.List<User>)
+
+    /**
+     * POST user/createWithList
+     * Creates list of users with given input array
+     * 
+     * Responses:
+     *  - 0: successful operation
+     *
+     * @param user List of user object
+     * @return [Unit]
+     */
+    @POST("user/createWithList")
+    suspend fun createUsersWithListInput(@Body user: kotlin.collections.List<User>)
+
+    /**
+     * DELETE user/{username}
+     * Delete user
+     * This can only be done by the logged in user.
+     * Responses:
+     *  - 400: Invalid username supplied
+     *  - 404: User not found
+     *
+     * @param username The name that needs to be deleted
+     * @return [Unit]
+     */
+    @DELETE("user/{username}")
+    suspend fun deleteUser(@Path("username") username: kotlin.String)
+
+    /**
+     * GET user/{username}
+     * Get user by user name
+     * 
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid username supplied
+     *  - 404: User not found
+     *
+     * @param username The name that needs to be fetched. Use user1 for testing.
+     * @return [User]
+     */
+    @GET("user/{username}")
+    suspend fun getUserByName(@Path("username") username: kotlin.String): User
+
+    /**
+     * GET user/login
+     * Logs user into the system
+     * 
+     * Responses:
+     *  - 200: successful operation
+     *  - 400: Invalid username/password supplied
+     *
+     * @param username The user name for login
+     * @param password The password for login in clear text
+     * @return [kotlin.String]
+     */
+    @GET("user/login")
+    suspend fun loginUser(@Query("username") username: kotlin.String, @Query("password") password: kotlin.String): kotlin.String
+
+    /**
+     * GET user/logout
+     * Logs out current logged in user session
+     * 
+     * Responses:
+     *  - 0: successful operation
+     *
+     * @return [Unit]
+     */
+    @GET("user/logout")
+    suspend fun logoutUser()
+
+    /**
+     * PUT user/{username}
+     * Updated user
+     * This can only be done by the logged in user.
+     * Responses:
+     *  - 400: Invalid user supplied
+     *  - 404: User not found
+     *
+     * @param username name that need to be deleted
+     * @param user Updated user object
+     * @return [Unit]
+     */
+    @PUT("user/{username}")
+    suspend fun updateUser(@Path("username") username: kotlin.String, @Body user: User)
+
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/auth/ApiKeyAuth.kt

@@ -0,0 +1,50 @@
+package org.openapitools.client.auth
+
+import java.io.IOException
+import java.net.URI
+import java.net.URISyntaxException
+
+import okhttp3.Interceptor
+import okhttp3.Response
+
+class ApiKeyAuth(
+        private val location: String = "",
+        private val paramName: String = "",
+        private var apiKey: String = ""
+) : Interceptor {
+
+    @Throws(IOException::class)
+    override fun intercept(chain: Interceptor.Chain): Response {
+        var request = chain.request()
+
+        if ("query" == location) {
+            var newQuery = request.url.toUri().query
+            val paramValue = "$paramName=$apiKey"
+            if (newQuery == null) {
+                newQuery = paramValue
+            } else {
+                newQuery += "&$paramValue"
+            }
+
+            val newUri: URI
+            try {
+                val oldUri = request.url.toUri()
+                newUri = URI(oldUri.scheme, oldUri.authority,
+                    oldUri.path, newQuery, oldUri.fragment)
+            } catch (e: URISyntaxException) {
+                throw IOException(e)
+            }
+
+            request = request.newBuilder().url(newUri.toURL()).build()
+        } else if ("header" == location) {
+            request = request.newBuilder()
+                    .addHeader(paramName, apiKey)
+                    .build()
+        } else if ("cookie" == location) {
+            request = request.newBuilder()
+                    .addHeader("Cookie", "$paramName=$apiKey")
+                    .build()
+        }
+        return chain.proceed(request)
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/auth/OAuth.kt

@@ -0,0 +1,151 @@
+package org.openapitools.client.auth
+
+import java.net.HttpURLConnection.HTTP_UNAUTHORIZED
+import java.net.HttpURLConnection.HTTP_FORBIDDEN
+
+import java.io.IOException
+
+import org.apache.oltu.oauth2.client.OAuthClient
+import org.apache.oltu.oauth2.client.request.OAuthBearerClientRequest
+import org.apache.oltu.oauth2.client.request.OAuthClientRequest
+import org.apache.oltu.oauth2.client.request.OAuthClientRequest.AuthenticationRequestBuilder
+import org.apache.oltu.oauth2.client.request.OAuthClientRequest.TokenRequestBuilder
+import org.apache.oltu.oauth2.common.exception.OAuthProblemException
+import org.apache.oltu.oauth2.common.exception.OAuthSystemException
+import org.apache.oltu.oauth2.common.message.types.GrantType
+import org.apache.oltu.oauth2.common.token.BasicOAuthToken
+
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Response
+
+class OAuth(
+        client: OkHttpClient,
+        var tokenRequestBuilder: TokenRequestBuilder
+) : Interceptor {
+
+    interface AccessTokenListener {
+        fun notify(token: BasicOAuthToken)
+    }
+
+    private var oauthClient: OAuthClient = OAuthClient(OAuthOkHttpClient(client))
+
+    @Volatile
+    private var accessToken: String? = null
+    var authenticationRequestBuilder: AuthenticationRequestBuilder? = null
+    private var accessTokenListener: AccessTokenListener? = null
+
+    constructor(
+            requestBuilder: TokenRequestBuilder
+    ) : this(
+            OkHttpClient(),
+            requestBuilder
+    )
+
+    constructor(
+            flow: OAuthFlow,
+            authorizationUrl: String,
+            tokenUrl: String,
+            scopes: String
+    ) : this(
+            OAuthClientRequest.tokenLocation(tokenUrl).setScope(scopes)
+    ) {
+        setFlow(flow)
+        authenticationRequestBuilder = OAuthClientRequest.authorizationLocation(authorizationUrl)
+    }
+
+    fun setFlow(flow: OAuthFlow) {
+        when (flow) {
+            OAuthFlow.accessCode, OAuthFlow.implicit ->
+                tokenRequestBuilder.setGrantType(GrantType.AUTHORIZATION_CODE)
+            OAuthFlow.password ->
+                tokenRequestBuilder.setGrantType(GrantType.PASSWORD)
+            OAuthFlow.application ->
+                tokenRequestBuilder.setGrantType(GrantType.CLIENT_CREDENTIALS)
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun intercept(chain: Interceptor.Chain): Response {
+        return retryingIntercept(chain, true)
+    }
+
+    @Throws(IOException::class)
+    private fun retryingIntercept(chain: Interceptor.Chain, updateTokenAndRetryOnAuthorizationFailure: Boolean): Response {
+        var request = chain.request()
+
+        // If the request already have an authorization (eg. Basic auth), do nothing
+        if (request.header("Authorization") != null) {
+            return chain.proceed(request)
+        }
+
+        // If first time, get the token
+        val oAuthRequest: OAuthClientRequest
+        if (accessToken == null) {
+            updateAccessToken(null)
+        }
+
+        if (accessToken != null) {
+            // Build the request
+            val rb = request.newBuilder()
+
+            val requestAccessToken = accessToken
+            try {
+                oAuthRequest = OAuthBearerClientRequest(request.url.toString())
+                        .setAccessToken(requestAccessToken)
+                        .buildHeaderMessage()
+            } catch (e: OAuthSystemException) {
+                throw IOException(e)
+            }
+
+            oAuthRequest.headers.entries.forEach { header ->
+                rb.addHeader(header.key, header.value)
+            }
+            rb.url(oAuthRequest.locationUri)
+
+            //Execute the request
+            val response = chain.proceed(rb.build())
+
+            // 401/403 most likely indicates that access token has expired. Unless it happens two times in a row.
+            if ((response.code == HTTP_UNAUTHORIZED || response.code == HTTP_FORBIDDEN) && updateTokenAndRetryOnAuthorizationFailure) {
+                try {
+                    if (updateAccessToken(requestAccessToken)) {
+                        response.body?.close()
+                        return retryingIntercept(chain, false)
+                    }
+                } catch (e: Exception) {
+                    response.body?.close()
+                    throw e
+                }
+            }
+            return response
+        } else {
+            return chain.proceed(chain.request())
+        }
+    }
+
+    /**
+     * Returns true if the access token has been updated
+     */
+    @Throws(IOException::class)
+    @Synchronized
+    fun updateAccessToken(requestAccessToken: String?): Boolean {
+        if (accessToken == null || accessToken.equals(requestAccessToken)) {
+            return try {
+                val accessTokenResponse = oauthClient.accessToken(this.tokenRequestBuilder.buildBodyMessage())
+                if (accessTokenResponse != null && accessTokenResponse.accessToken != null) {
+                    accessToken = accessTokenResponse.accessToken
+                    accessTokenListener?.notify(accessTokenResponse.oAuthToken as BasicOAuthToken)
+                    !accessToken.equals(requestAccessToken)
+                } else {
+                    false
+                }
+            } catch (e: OAuthSystemException) {
+                throw IOException(e)
+            } catch (e: OAuthProblemException) {
+                throw IOException(e)
+            }
+        }
+        return true
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/auth/OAuthFlow.kt

@@ -0,0 +1,5 @@
+package org.openapitools.client.auth
+
+enum class OAuthFlow {
+    accessCode, implicit, password, application
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/auth/OAuthOkHttpClient.kt

@@ -0,0 +1,61 @@
+package org.openapitools.client.auth
+
+import java.io.IOException
+
+import org.apache.oltu.oauth2.client.HttpClient
+import org.apache.oltu.oauth2.client.request.OAuthClientRequest
+import org.apache.oltu.oauth2.client.response.OAuthClientResponse
+import org.apache.oltu.oauth2.client.response.OAuthClientResponseFactory
+import org.apache.oltu.oauth2.common.exception.OAuthProblemException
+import org.apache.oltu.oauth2.common.exception.OAuthSystemException
+
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+
+
+class OAuthOkHttpClient(
+        private var client: OkHttpClient = OkHttpClient()
+) : HttpClient {
+
+    @Throws(OAuthSystemException::class, OAuthProblemException::class)
+    override fun <T : OAuthClientResponse?> execute(
+            request: OAuthClientRequest,
+            headers: Map<String, String>?,
+            requestMethod: String,
+            responseClass: Class<T>?): T {
+
+        var mediaType = "application/json".toMediaTypeOrNull()
+        val requestBuilder = Request.Builder().url(request.locationUri)
+
+        headers?.forEach { entry ->
+            if (entry.key.equals("Content-Type", true)) {
+                mediaType = entry.value.toMediaTypeOrNull()
+            } else {
+                requestBuilder.addHeader(entry.key, entry.value)
+            }
+        }
+
+        val body: RequestBody? = if (request.body != null) request.body.toRequestBody(mediaType) else null
+        requestBuilder.method(requestMethod, body)
+
+        try {
+            val response = client.newCall(requestBuilder.build()).execute()
+            return OAuthClientResponseFactory.createCustomResponse(
+                    response.body?.string(),
+                    response.body?.contentType()?.toString(),
+                    response.code,
+                    response.headers.toMultimap(),
+                    responseClass)
+        } catch (e: IOException) {
+            throw OAuthSystemException(e)
+        }
+    }
+
+    override fun shutdown() {
+        // Nothing to do here
+    }
+
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt

@@ -0,0 +1,223 @@
+package org.openapitools.client.infrastructure
+
+import org.apache.oltu.oauth2.client.request.OAuthClientRequest.AuthenticationRequestBuilder
+import org.apache.oltu.oauth2.client.request.OAuthClientRequest.TokenRequestBuilder
+import org.openapitools.client.auth.OAuth
+import org.openapitools.client.auth.OAuth.AccessTokenListener
+import org.openapitools.client.auth.OAuthFlow
+import org.openapitools.client.auth.ApiKeyAuth
+
+import okhttp3.Call
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import retrofit2.Retrofit
+import okhttp3.logging.HttpLoggingInterceptor
+import retrofit2.Converter
+import retrofit2.CallAdapter
+import retrofit2.converter.scalars.ScalarsConverterFactory
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import retrofit2.converter.gson.GsonConverterFactory
+
+
+class ApiClient(
+    private var baseUrl: String = defaultBasePath,
+    private val okHttpClientBuilder: OkHttpClient.Builder? = null,
+    private val serializerBuilder: GsonBuilder = Serializer.gsonBuilder,
+    private val callFactory: Call.Factory? = null,
+    private val callAdapterFactories: List<CallAdapter.Factory> = listOf(
+    ),
+    private val converterFactories: List<Converter.Factory> = listOf(
+        ScalarsConverterFactory.create(),
+        GsonConverterFactory.create(serializerBuilder.create()),
+    )
+) {
+    private val apiAuthorizations = mutableMapOf<String, Interceptor>()
+    var logger: ((String) -> Unit)? = null
+
+    private val retrofitBuilder: Retrofit.Builder by lazy {
+        Retrofit.Builder()
+            .baseUrl(baseUrl)
+            .apply {
+                callAdapterFactories.forEach {
+                    addCallAdapterFactory(it)
+                }
+            }
+            .apply {
+                converterFactories.forEach {
+                    addConverterFactory(it)
+                }
+            }
+    }
+
+    private val clientBuilder: OkHttpClient.Builder by lazy {
+        okHttpClientBuilder ?: defaultClientBuilder
+    }
+
+    private val defaultClientBuilder: OkHttpClient.Builder by lazy {
+        OkHttpClient()
+            .newBuilder()
+            .addInterceptor(HttpLoggingInterceptor { message -> logger?.invoke(message) }
+                .apply { level = HttpLoggingInterceptor.Level.BODY }
+            )
+    }
+
+    init {
+        normalizeBaseUrl()
+    }
+
+    constructor(
+        baseUrl: String = defaultBasePath,
+        okHttpClientBuilder: OkHttpClient.Builder? = null,
+        serializerBuilder: GsonBuilder = Serializer.gsonBuilder,
+        authNames: Array<String>
+    ) : this(baseUrl, okHttpClientBuilder, serializerBuilder) {
+        authNames.forEach { authName ->
+            val auth: Interceptor? = when (authName) { 
+                "petstore_auth" -> OAuth(OAuthFlow.implicit, "http://petstore.swagger.io/api/oauth/dialog", "", "write:pets, read:pets")
+                
+                "api_key" -> ApiKeyAuth("header", "api_key")
+                
+                else -> throw RuntimeException("auth name $authName not found in available auth names")
+            }
+            if (auth != null) {
+                addAuthorization(authName, auth)
+            }
+        }
+    }
+
+    constructor(
+        baseUrl: String = defaultBasePath,
+        okHttpClientBuilder: OkHttpClient.Builder? = null,
+        serializerBuilder: GsonBuilder = Serializer.gsonBuilder,
+        authName: String,
+        clientId: String,
+        secret: String,
+        username: String,
+        password: String
+    ) : this(baseUrl, okHttpClientBuilder, serializerBuilder, arrayOf(authName)) {
+        getTokenEndPoint()
+            ?.setClientId(clientId)
+            ?.setClientSecret(secret)
+            ?.setUsername(username)
+            ?.setPassword(password)
+    }
+
+    /**
+     * Helper method to configure the token endpoint of the first oauth found in the apiAuthorizations (there should be only one)
+     * @return Token request builder
+     */
+    fun getTokenEndPoint(): TokenRequestBuilder? {
+        var result: TokenRequestBuilder? = null
+        apiAuthorizations.values.runOnFirst<Interceptor, OAuth> {
+            result = tokenRequestBuilder
+        }
+        return result
+    }
+
+    /**
+     * Helper method to configure authorization endpoint of the first oauth found in the apiAuthorizations (there should be only one)
+     * @return Authentication request builder
+     */
+    fun getAuthorizationEndPoint(): AuthenticationRequestBuilder? {
+        var result: AuthenticationRequestBuilder? = null
+        apiAuthorizations.values.runOnFirst<Interceptor, OAuth> {
+            result = authenticationRequestBuilder
+        }
+        return result
+    }
+
+    /**
+     * Helper method to pre-set the oauth access token of the first oauth found in the apiAuthorizations (there should be only one)
+     * @param accessToken Access token
+     * @return ApiClient
+     */
+    fun setAccessToken(accessToken: String): ApiClient {
+        apiAuthorizations.values.runOnFirst<Interceptor, OAuth> {
+            setAccessToken(accessToken)
+        }
+        return this
+    }
+
+    /**
+     * Helper method to configure the oauth accessCode/implicit flow parameters
+     * @param clientId Client ID
+     * @param clientSecret Client secret
+     * @param redirectURI Redirect URI
+     * @return ApiClient
+     */
+    fun configureAuthorizationFlow(clientId: String, clientSecret: String, redirectURI: String): ApiClient {
+        apiAuthorizations.values.runOnFirst<Interceptor, OAuth> {
+            tokenRequestBuilder
+                .setClientId(clientId)
+                .setClientSecret(clientSecret)
+                .setRedirectURI(redirectURI)
+            authenticationRequestBuilder
+                ?.setClientId(clientId)
+                ?.setRedirectURI(redirectURI)
+        }
+        return this
+    }
+
+    /**
+     * Configures a listener which is notified when a new access token is received.
+     * @param accessTokenListener Access token listener
+     * @return ApiClient
+     */
+    fun registerAccessTokenListener(accessTokenListener: AccessTokenListener): ApiClient {
+        apiAuthorizations.values.runOnFirst<Interceptor, OAuth> {
+            registerAccessTokenListener(accessTokenListener)
+        }
+        return this
+    }
+
+    /**
+     * Adds an authorization to be used by the client
+     * @param authName Authentication name
+     * @param authorization Authorization interceptor
+     * @return ApiClient
+     */
+    fun addAuthorization(authName: String, authorization: Interceptor): ApiClient {
+        if (apiAuthorizations.containsKey(authName)) {
+            throw RuntimeException("auth name $authName already in api authorizations")
+        }
+        apiAuthorizations[authName] = authorization
+        clientBuilder.addInterceptor(authorization)
+        return this
+    }
+
+    fun setLogger(logger: (String) -> Unit): ApiClient {
+        this.logger = logger
+        return this
+    }
+
+    fun <S> createService(serviceClass: Class<S>): S {
+        val usedCallFactory = this.callFactory ?: clientBuilder.build()
+        return retrofitBuilder.callFactory(usedCallFactory).build().create(serviceClass)
+    }
+
+    private fun normalizeBaseUrl() {
+        if (!baseUrl.endsWith("/")) {
+            baseUrl += "/"
+        }
+    }
+
+    private inline fun <T, reified U> Iterable<T>.runOnFirst(callback: U.() -> Unit) {
+        for (element in this) {
+            if (element is U) {
+                callback.invoke(element)
+                break
+            }
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        protected val baseUrlKey: String = "org.openapitools.client.baseUrl"
+
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(baseUrlKey, "http://petstore.swagger.io/v2")
+        }
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/ByteArrayAdapter.kt

@@ -0,0 +1,33 @@
+package org.openapitools.client.infrastructure
+
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonReader
+import com.google.gson.stream.JsonWriter
+import com.google.gson.stream.JsonToken.NULL
+import java.io.IOException
+
+class ByteArrayAdapter : TypeAdapter<ByteArray>() {
+    @Throws(IOException::class)
+    override fun write(out: JsonWriter?, value: ByteArray?) {
+        if (value == null) {
+            out?.nullValue()
+        } else {
+            out?.value(String(value))
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun read(out: JsonReader?): ByteArray? {
+        out ?: return null
+
+        when (out.peek()) {
+            NULL -> {
+                out.nextNull()
+                return null
+            }
+            else -> {
+                return out.nextString().toByteArray()
+            }
+        }
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/CollectionFormats.kt

@@ -0,0 +1,56 @@
+package org.openapitools.client.infrastructure
+
+class CollectionFormats {
+
+    open class CSVParams {
+
+        var params: List<String>
+
+        constructor(params: List<String>) {
+            this.params = params
+        }
+
+        constructor(vararg params: String) {
+            this.params = listOf(*params)
+        }
+
+        override fun toString(): String {
+            return params.joinToString(",")
+        }
+    }
+
+    open class SSVParams : CSVParams {
+
+        constructor(params: List<String>) : super(params)
+
+        constructor(vararg params: String) : super(*params)
+
+        override fun toString(): String {
+            return params.joinToString(" ")
+        }
+    }
+
+    class TSVParams : CSVParams {
+
+        constructor(params: List<String>) : super(params)
+
+        constructor(vararg params: String) : super(*params)
+
+        override fun toString(): String {
+            return params.joinToString("\t")
+        }
+    }
+
+    class PIPESParams : CSVParams {
+
+        constructor(params: List<String>) : super(params)
+
+        constructor(vararg params: String) : super(*params)
+
+        override fun toString(): String {
+            return params.joinToString("|")
+        }
+    }
+
+    class SPACEParams : SSVParams()
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/LocalDateAdapter.kt

@@ -0,0 +1,35 @@
+package org.openapitools.client.infrastructure
+
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonReader
+import com.google.gson.stream.JsonWriter
+import com.google.gson.stream.JsonToken.NULL
+import java.io.IOException
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+class LocalDateAdapter(private val formatter: DateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE) : TypeAdapter<LocalDate>() {
+    @Throws(IOException::class)
+    override fun write(out: JsonWriter?, value: LocalDate?) {
+        if (value == null) {
+            out?.nullValue()
+        } else {
+            out?.value(formatter.format(value))
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun read(out: JsonReader?): LocalDate? {
+        out ?: return null
+
+        when (out.peek()) {
+            NULL -> {
+                out.nextNull()
+                return null
+            }
+            else -> {
+                return LocalDate.parse(out.nextString(), formatter)
+            }
+        }
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/LocalDateTimeAdapter.kt

@@ -0,0 +1,35 @@
+package org.openapitools.client.infrastructure
+
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonReader
+import com.google.gson.stream.JsonWriter
+import com.google.gson.stream.JsonToken.NULL
+import java.io.IOException
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+
+class LocalDateTimeAdapter(private val formatter: DateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME) : TypeAdapter<LocalDateTime>() {
+    @Throws(IOException::class)
+    override fun write(out: JsonWriter?, value: LocalDateTime?) {
+        if (value == null) {
+            out?.nullValue()
+        } else {
+            out?.value(formatter.format(value))
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun read(out: JsonReader?): LocalDateTime? {
+        out ?: return null
+
+        when (out.peek()) {
+            NULL -> {
+                out.nextNull()
+                return null
+            }
+            else -> {
+                return LocalDateTime.parse(out.nextString(), formatter)
+            }
+        }
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/OffsetDateTimeAdapter.kt

@@ -0,0 +1,35 @@
+package org.openapitools.client.infrastructure
+
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonReader
+import com.google.gson.stream.JsonWriter
+import com.google.gson.stream.JsonToken.NULL
+import java.io.IOException
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+
+class OffsetDateTimeAdapter(private val formatter: DateTimeFormatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME) : TypeAdapter<OffsetDateTime>() {
+    @Throws(IOException::class)
+    override fun write(out: JsonWriter?, value: OffsetDateTime?) {
+        if (value == null) {
+            out?.nullValue()
+        } else {
+            out?.value(formatter.format(value))
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun read(out: JsonReader?): OffsetDateTime? {
+        out ?: return null
+
+        when (out.peek()) {
+            NULL -> {
+                out.nextNull()
+                return null
+            }
+            else -> {
+                return OffsetDateTime.parse(out.nextString(), formatter)
+            }
+        }
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/ResponseExt.kt

@@ -0,0 +1,15 @@
+package org.openapitools.client.infrastructure
+
+import com.google.gson.GsonBuilder
+import com.google.gson.JsonParseException
+import retrofit2.Response
+
+@Throws(JsonParseException::class)
+inline fun <reified T> Response<*>.getErrorResponse(serializerBuilder: GsonBuilder = Serializer.gsonBuilder): T? {
+    val serializer = serializerBuilder.create()
+    val reader = errorBody()?.charStream()
+    if (reader != null) {
+        return serializer.fromJson(reader, T::class.java)
+    }
+    return null
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/infrastructure/Serializer.kt

@@ -0,0 +1,22 @@
+package org.openapitools.client.infrastructure
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.OffsetDateTime
+import java.util.UUID
+
+object Serializer {
+    @JvmStatic
+    val gsonBuilder: GsonBuilder = GsonBuilder()
+        .registerTypeAdapter(OffsetDateTime::class.java, OffsetDateTimeAdapter())
+        .registerTypeAdapter(LocalDateTime::class.java, LocalDateTimeAdapter())
+        .registerTypeAdapter(LocalDate::class.java, LocalDateAdapter())
+        .registerTypeAdapter(ByteArray::class.java, ByteArrayAdapter())
+
+    @JvmStatic
+    val gson: Gson by lazy {
+        gsonBuilder.create()
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/models/Category.kt

@@ -0,0 +1,45 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+
+import com.google.gson.annotations.SerializedName
+import java.io.Serializable
+
+/**
+ * A category for a pet
+ *
+ * @param id 
+ * @param name 
+ */
+
+
+data class Category (
+
+    @SerializedName("id")
+    val id: kotlin.Long? = null,
+
+    @SerializedName("name")
+    val name: kotlin.String? = null
+
+) : Serializable {
+    companion object {
+        private const val serialVersionUID: Long = 123
+    }
+
+
+}
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/models/ModelApiResponse.kt

@@ -0,0 +1,49 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+
+import com.google.gson.annotations.SerializedName
+import java.io.Serializable
+
+/**
+ * Describes the result of uploading an image resource
+ *
+ * @param code 
+ * @param type 
+ * @param message 
+ */
+
+
+data class ModelApiResponse (
+
+    @SerializedName("code")
+    val code: kotlin.Int? = null,
+
+    @SerializedName("type")
+    val type: kotlin.String? = null,
+
+    @SerializedName("message")
+    val message: kotlin.String? = null
+
+) : Serializable {
+    companion object {
+        private const val serialVersionUID: Long = 123
+    }
+
+
+}
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/models/Order.kt

@@ -0,0 +1,72 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+
+import com.google.gson.annotations.SerializedName
+import java.io.Serializable
+
+/**
+ * An order for a pets from the pet store
+ *
+ * @param id 
+ * @param petId 
+ * @param quantity 
+ * @param shipDate 
+ * @param status Order Status
+ * @param complete 
+ */
+
+
+data class Order (
+
+    @SerializedName("id")
+    val id: kotlin.Long? = null,
+
+    @SerializedName("petId")
+    val petId: kotlin.Long? = null,
+
+    @SerializedName("quantity")
+    val quantity: kotlin.Int? = null,
+
+    @SerializedName("shipDate")
+    val shipDate: java.time.OffsetDateTime? = null,
+
+    /* Order Status */
+    @SerializedName("status")
+    val status: Order.Status? = null,
+
+    @SerializedName("complete")
+    val complete: kotlin.Boolean? = false
+
+) : Serializable {
+    companion object {
+        private const val serialVersionUID: Long = 123
+    }
+
+    /**
+     * Order Status
+     *
+     * Values: placed,approved,delivered
+     */
+    enum class Status(val value: kotlin.String) {
+        @SerializedName(value = "placed") placed("placed"),
+        @SerializedName(value = "approved") approved("approved"),
+        @SerializedName(value = "delivered") delivered("delivered");
+    }
+
+}
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/models/Pet.kt

@@ -0,0 +1,75 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import org.openapitools.client.models.Category
+import org.openapitools.client.models.Tag
+
+import com.google.gson.annotations.SerializedName
+import java.io.Serializable
+
+/**
+ * A pet for sale in the pet store
+ *
+ * @param name 
+ * @param photoUrls 
+ * @param id 
+ * @param category 
+ * @param tags 
+ * @param status pet status in the store
+ */
+
+
+data class Pet (
+
+    @SerializedName("name")
+    val name: kotlin.String,
+
+    @SerializedName("photoUrls")
+    val photoUrls: kotlin.collections.List<kotlin.String>,
+
+    @SerializedName("id")
+    val id: kotlin.Long? = null,
+
+    @SerializedName("category")
+    val category: Category? = null,
+
+    @SerializedName("tags")
+    val tags: kotlin.collections.List<Tag>? = null,
+
+    /* pet status in the store */
+    @SerializedName("status")
+    @Deprecated(message = "This property is deprecated.")
+    val status: Pet.Status? = null
+
+) : Serializable {
+    companion object {
+        private const val serialVersionUID: Long = 123
+    }
+
+    /**
+     * pet status in the store
+     *
+     * Values: available,pending,sold
+     */
+    enum class Status(val value: kotlin.String) {
+        @SerializedName(value = "available") available("available"),
+        @SerializedName(value = "pending") pending("pending"),
+        @SerializedName(value = "sold") sold("sold");
+    }
+
+}
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/models/Tag.kt

@@ -0,0 +1,45 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+
+import com.google.gson.annotations.SerializedName
+import java.io.Serializable
+
+/**
+ * A tag for a pet
+ *
+ * @param id 
+ * @param name 
+ */
+
+
+data class Tag (
+
+    @SerializedName("id")
+    val id: kotlin.Long? = null,
+
+    @SerializedName("name")
+    val name: kotlin.String? = null
+
+) : Serializable {
+    companion object {
+        private const val serialVersionUID: Long = 123
+    }
+
+
+}
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/main/kotlin/org/openapitools/client/models/User.kt

@@ -0,0 +1,70 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+
+import com.google.gson.annotations.SerializedName
+import java.io.Serializable
+
+/**
+ * A User who is purchasing from the pet store
+ *
+ * @param id 
+ * @param username 
+ * @param firstName 
+ * @param lastName 
+ * @param email 
+ * @param password 
+ * @param phone 
+ * @param userStatus User Status
+ */
+
+
+data class User (
+
+    @SerializedName("id")
+    val id: kotlin.Long? = null,
+
+    @SerializedName("username")
+    val username: kotlin.String? = null,
+
+    @SerializedName("firstName")
+    val firstName: kotlin.String? = null,
+
+    @SerializedName("lastName")
+    val lastName: kotlin.String? = null,
+
+    @SerializedName("email")
+    val email: kotlin.String? = null,
+
+    @SerializedName("password")
+    val password: kotlin.String? = null,
+
+    @SerializedName("phone")
+    val phone: kotlin.String? = null,
+
+    /* User Status */
+    @SerializedName("userStatus")
+    val userStatus: kotlin.Int? = null
+
+) : Serializable {
+    companion object {
+        private const val serialVersionUID: Long = 123
+    }
+
+
+}
+

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/apis/PetApiTest.kt

@@ -0,0 +1,98 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.apis
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.apis.PetApi
+import org.openapitools.client.models.ModelApiResponse
+import org.openapitools.client.models.Pet
+
+class PetApiTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of PetApi
+        //val apiInstance = PetApi()
+
+        // to test addPet
+        should("test addPet") {
+            // uncomment below to test addPet
+            //val pet : Pet =  // Pet | Pet object that needs to be added to the store
+            //val result : Pet = apiInstance.addPet(pet)
+            //result shouldBe ("TODO")
+        }
+
+        // to test deletePet
+        should("test deletePet") {
+            // uncomment below to test deletePet
+            //val petId : kotlin.Long = 789 // kotlin.Long | Pet id to delete
+            //val apiKey : kotlin.String = apiKey_example // kotlin.String | 
+            //apiInstance.deletePet(petId, apiKey)
+        }
+
+        // to test findPetsByStatus
+        should("test findPetsByStatus") {
+            // uncomment below to test findPetsByStatus
+            //val status : kotlin.collections.List<kotlin.String> =  // kotlin.collections.List<kotlin.String> | Status values that need to be considered for filter
+            //val result : kotlin.collections.List<Pet> = apiInstance.findPetsByStatus(status)
+            //result shouldBe ("TODO")
+        }
+
+        // to test findPetsByTags
+        should("test findPetsByTags") {
+            // uncomment below to test findPetsByTags
+            //val tags : kotlin.collections.List<kotlin.String> =  // kotlin.collections.List<kotlin.String> | Tags to filter by
+            //val result : kotlin.collections.List<Pet> = apiInstance.findPetsByTags(tags)
+            //result shouldBe ("TODO")
+        }
+
+        // to test getPetById
+        should("test getPetById") {
+            // uncomment below to test getPetById
+            //val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to return
+            //val result : Pet = apiInstance.getPetById(petId)
+            //result shouldBe ("TODO")
+        }
+
+        // to test updatePet
+        should("test updatePet") {
+            // uncomment below to test updatePet
+            //val pet : Pet =  // Pet | Pet object that needs to be added to the store
+            //val result : Pet = apiInstance.updatePet(pet)
+            //result shouldBe ("TODO")
+        }
+
+        // to test updatePetWithForm
+        should("test updatePetWithForm") {
+            // uncomment below to test updatePetWithForm
+            //val petId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be updated
+            //val name : kotlin.String = name_example // kotlin.String | Updated name of the pet
+            //val status : kotlin.String = status_example // kotlin.String | Updated status of the pet
+            //apiInstance.updatePetWithForm(petId, name, status)
+        }
+
+        // to test uploadFile
+        should("test uploadFile") {
+            // uncomment below to test uploadFile
+            //val petId : kotlin.Long = 789 // kotlin.Long | ID of pet to update
+            //val additionalMetadata : kotlin.String = additionalMetadata_example // kotlin.String | Additional data to pass to server
+            //val file : java.io.File = BINARY_DATA_HERE // java.io.File | file to upload
+            //val result : ModelApiResponse = apiInstance.uploadFile(petId, additionalMetadata, file)
+            //result shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/apis/StoreApiTest.kt

@@ -0,0 +1,60 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.apis
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.apis.StoreApi
+import org.openapitools.client.models.Order
+
+class StoreApiTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of StoreApi
+        //val apiInstance = StoreApi()
+
+        // to test deleteOrder
+        should("test deleteOrder") {
+            // uncomment below to test deleteOrder
+            //val orderId : kotlin.String = orderId_example // kotlin.String | ID of the order that needs to be deleted
+            //apiInstance.deleteOrder(orderId)
+        }
+
+        // to test getInventory
+        should("test getInventory") {
+            // uncomment below to test getInventory
+            //val result : kotlin.collections.Map<kotlin.String, kotlin.Int> = apiInstance.getInventory()
+            //result shouldBe ("TODO")
+        }
+
+        // to test getOrderById
+        should("test getOrderById") {
+            // uncomment below to test getOrderById
+            //val orderId : kotlin.Long = 789 // kotlin.Long | ID of pet that needs to be fetched
+            //val result : Order = apiInstance.getOrderById(orderId)
+            //result shouldBe ("TODO")
+        }
+
+        // to test placeOrder
+        should("test placeOrder") {
+            // uncomment below to test placeOrder
+            //val order : Order =  // Order | order placed for purchasing the pet
+            //val result : Order = apiInstance.placeOrder(order)
+            //result shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/apis/UserApiTest.kt

@@ -0,0 +1,89 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.apis
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.apis.UserApi
+import org.openapitools.client.models.User
+
+class UserApiTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of UserApi
+        //val apiInstance = UserApi()
+
+        // to test createUser
+        should("test createUser") {
+            // uncomment below to test createUser
+            //val user : User =  // User | Created user object
+            //apiInstance.createUser(user)
+        }
+
+        // to test createUsersWithArrayInput
+        should("test createUsersWithArrayInput") {
+            // uncomment below to test createUsersWithArrayInput
+            //val user : kotlin.collections.List<User> =  // kotlin.collections.List<User> | List of user object
+            //apiInstance.createUsersWithArrayInput(user)
+        }
+
+        // to test createUsersWithListInput
+        should("test createUsersWithListInput") {
+            // uncomment below to test createUsersWithListInput
+            //val user : kotlin.collections.List<User> =  // kotlin.collections.List<User> | List of user object
+            //apiInstance.createUsersWithListInput(user)
+        }
+
+        // to test deleteUser
+        should("test deleteUser") {
+            // uncomment below to test deleteUser
+            //val username : kotlin.String = username_example // kotlin.String | The name that needs to be deleted
+            //apiInstance.deleteUser(username)
+        }
+
+        // to test getUserByName
+        should("test getUserByName") {
+            // uncomment below to test getUserByName
+            //val username : kotlin.String = username_example // kotlin.String | The name that needs to be fetched. Use user1 for testing.
+            //val result : User = apiInstance.getUserByName(username)
+            //result shouldBe ("TODO")
+        }
+
+        // to test loginUser
+        should("test loginUser") {
+            // uncomment below to test loginUser
+            //val username : kotlin.String = username_example // kotlin.String | The user name for login
+            //val password : kotlin.String = password_example // kotlin.String | The password for login in clear text
+            //val result : kotlin.String = apiInstance.loginUser(username, password)
+            //result shouldBe ("TODO")
+        }
+
+        // to test logoutUser
+        should("test logoutUser") {
+            // uncomment below to test logoutUser
+            //apiInstance.logoutUser()
+        }
+
+        // to test updateUser
+        should("test updateUser") {
+            // uncomment below to test updateUser
+            //val username : kotlin.String = username_example // kotlin.String | name that need to be deleted
+            //val user : User =  // User | Updated user object
+            //apiInstance.updateUser(username, user)
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/models/ApiResponseTest.kt

@@ -0,0 +1,47 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.models.ModelApiResponse
+
+class ModelApiResponseTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of ModelApiResponse
+        //val modelInstance = ModelApiResponse()
+
+        // to test the property `code`
+        should("test code") {
+            // uncomment below to test the property
+            //modelInstance.code shouldBe ("TODO")
+        }
+
+        // to test the property `type`
+        should("test type") {
+            // uncomment below to test the property
+            //modelInstance.type shouldBe ("TODO")
+        }
+
+        // to test the property `message`
+        should("test message") {
+            // uncomment below to test the property
+            //modelInstance.message shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/models/CategoryTest.kt

@@ -0,0 +1,41 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.models.Category
+
+class CategoryTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of Category
+        //val modelInstance = Category()
+
+        // to test the property `id`
+        should("test id") {
+            // uncomment below to test the property
+            //modelInstance.id shouldBe ("TODO")
+        }
+
+        // to test the property `name`
+        should("test name") {
+            // uncomment below to test the property
+            //modelInstance.name shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/models/OrderTest.kt

@@ -0,0 +1,65 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.models.Order
+
+class OrderTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of Order
+        //val modelInstance = Order()
+
+        // to test the property `id`
+        should("test id") {
+            // uncomment below to test the property
+            //modelInstance.id shouldBe ("TODO")
+        }
+
+        // to test the property `petId`
+        should("test petId") {
+            // uncomment below to test the property
+            //modelInstance.petId shouldBe ("TODO")
+        }
+
+        // to test the property `quantity`
+        should("test quantity") {
+            // uncomment below to test the property
+            //modelInstance.quantity shouldBe ("TODO")
+        }
+
+        // to test the property `shipDate`
+        should("test shipDate") {
+            // uncomment below to test the property
+            //modelInstance.shipDate shouldBe ("TODO")
+        }
+
+        // to test the property `status` - Order Status
+        should("test status") {
+            // uncomment below to test the property
+            //modelInstance.status shouldBe ("TODO")
+        }
+
+        // to test the property `complete`
+        should("test complete") {
+            // uncomment below to test the property
+            //modelInstance.complete shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/models/PetTest.kt

@@ -0,0 +1,67 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.models.Pet
+import org.openapitools.client.models.Category
+import org.openapitools.client.models.Tag
+
+class PetTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of Pet
+        //val modelInstance = Pet()
+
+        // to test the property `name`
+        should("test name") {
+            // uncomment below to test the property
+            //modelInstance.name shouldBe ("TODO")
+        }
+
+        // to test the property `photoUrls`
+        should("test photoUrls") {
+            // uncomment below to test the property
+            //modelInstance.photoUrls shouldBe ("TODO")
+        }
+
+        // to test the property `id`
+        should("test id") {
+            // uncomment below to test the property
+            //modelInstance.id shouldBe ("TODO")
+        }
+
+        // to test the property `category`
+        should("test category") {
+            // uncomment below to test the property
+            //modelInstance.category shouldBe ("TODO")
+        }
+
+        // to test the property `tags`
+        should("test tags") {
+            // uncomment below to test the property
+            //modelInstance.tags shouldBe ("TODO")
+        }
+
+        // to test the property `status` - pet status in the store
+        should("test status") {
+            // uncomment below to test the property
+            //modelInstance.status shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/models/TagTest.kt

@@ -0,0 +1,41 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.models.Tag
+
+class TagTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of Tag
+        //val modelInstance = Tag()
+
+        // to test the property `id`
+        should("test id") {
+            // uncomment below to test the property
+            //modelInstance.id shouldBe ("TODO")
+        }
+
+        // to test the property `name`
+        should("test name") {
+            // uncomment below to test the property
+            //modelInstance.name shouldBe ("TODO")
+        }
+
+    }
+}

samples/client/petstore/kotlin-jvm-retrofit2-coroutines/src/test/kotlin/org/openapitools/client/models/UserTest.kt

@@ -0,0 +1,77 @@
+/**
+ *
+ * Please note:
+ * This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * Do not edit this file manually.
+ *
+ */
+
+@file:Suppress(
+    "ArrayInDataClass",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "UnusedImport"
+)
+
+package org.openapitools.client.models
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.ShouldSpec
+
+import org.openapitools.client.models.User
+
+class UserTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of User
+        //val modelInstance = User()
+
+        // to test the property `id`
+        should("test id") {
+            // uncomment below to test the property
+            //modelInstance.id shouldBe ("TODO")
+        }
+
+        // to test the property `username`
+        should("test username") {
+            // uncomment below to test the property
+            //modelInstance.username shouldBe ("TODO")
+        }
+
+        // to test the property `firstName`
+        should("test firstName") {
+            // uncomment below to test the property
+            //modelInstance.firstName shouldBe ("TODO")
+        }
+
+        // to test the property `lastName`
+        should("test lastName") {
+            // uncomment below to test the property
+            //modelInstance.lastName shouldBe ("TODO")
+        }
+
+        // to test the property `email`
+        should("test email") {
+            // uncomment below to test the property
+            //modelInstance.email shouldBe ("TODO")
+        }
+
+        // to test the property `password`
+        should("test password") {
+            // uncomment below to test the property
+            //modelInstance.password shouldBe ("TODO")
+        }
+
+        // to test the property `phone`
+        should("test phone") {
+            // uncomment below to test the property
+            //modelInstance.phone shouldBe ("TODO")
+        }
+
+        // to test the property `userStatus` - User Status
+        should("test userStatus") {
+            // uncomment below to test the property
+            //modelInstance.userStatus shouldBe ("TODO")
+        }
+
+    }
+}