Kotlinx polymorphism with custom discriminator support (#21531)

* kotlinx serialization fixes - added new config with kotlinx, discriminator (/w custom name) and kotlinx_serialization - remove discriminator properties from the generator in both base and derived classes - set discriminatorValue in additionalProperties of derived classes - add JsonClassDiscriminator the derived classes in the template - set SerialName to discriminatorValue in the template - change base classes to sealed class instead of interface - make variables in base classes abstract * Generated kotlin-allOff-discriminator-kotlinx-serialization sample * Added test for kotlinx_serialization with discriminator * renamed yaml * Added new sample to github workflow * Added comments to KotlinClientCodegen::postProcessAllModels
2025-07-31 10:29:39 +02:00
parent d7a8aae6e2
commit dba7aee41e
49 changed files with 1952 additions and 4 deletions
--- a/.github/workflows/samples-kotlin-client.yaml
+++ b/.github/workflows/samples-kotlin-client.yaml
@@ -66,6 +66,7 @@ jobs:
          - samples/client/petstore/kotlin-name-parameter-mappings
          - samples/client/others/kotlin-jvm-okhttp-parameter-tests
          - samples/client/others/kotlin-jvm-okhttp-path-comments
+          - samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
--- a/bin/configs/kotlin-allOff-discriminator-kotlinx-serialization.yaml
+++ b/bin/configs/kotlin-allOff-discriminator-kotlinx-serialization.yaml
@@ -0,0 +1,10 @@
+generatorName: kotlin
+outputDir: samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization
+inputSpec: modules/openapi-generator/src/test/resources/3_0/kotlin/polymorphism.yaml
+templateDir: modules/openapi-generator/src/main/resources/kotlin-client
+additionalProperties:
+  artifactId: kotlin-allOff-discriminator
+  serializableModel: "false"
+  dateLibrary: java8
+  enumUnknownDefaultCase: true
+  serializationLibrary: kotlinx_serialization
--- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinClientCodegen.java
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinClientCodegen.java
@@ -963,6 +963,44 @@ public class KotlinClientCodegen extends AbstractKotlinCodegen {
        return objects;
    }

+    @Override
+    public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs) {
+        objs = super.postProcessAllModels(objs);
+        if (getSerializationLibrary() == SERIALIZATION_LIBRARY_TYPE.kotlinx_serialization) {
+            // The loop removes unneeded variables so commas are handled correctly in the related templates
+            for (Map.Entry<String, ModelsMap> modelsMap : objs.entrySet()) {
+                for (ModelMap mo : modelsMap.getValue().getModels()) {
+                    CodegenModel cm = mo.getModel();
+                    CodegenDiscriminator discriminator = cm.getDiscriminator();
+                    if (discriminator == null) {
+                        continue;
+                    }
+                    // Remove discriminator property from the base class, it is not needed in the generated code
+                    getAllVarProperties(cm).forEach(list -> list.removeIf(var -> var.name == discriminator.getPropertyName()));
+
+                    for (CodegenDiscriminator.MappedModel mappedModel : discriminator.getMappedModels()) {
+                        // Add the mapping name to additionalProperties.disciminatorValue
+                        // The mapping name is used to define SerializedName, which in result makes derived classes
+                        // found by kotlinx-serialization during deserialization
+                        CodegenProperty additionalProperties = mappedModel.getModel().getAdditionalProperties();
+                        if (additionalProperties == null) {
+                            additionalProperties = new CodegenProperty();
+                            mappedModel.getModel().setAdditionalProperties(additionalProperties);
+                        }
+                        additionalProperties.discriminatorValue = mappedModel.getMappingName();
+                        // Remove the discriminator property from the derived class, it is not needed in the generated code
+                        getAllVarProperties(mappedModel.getModel()).forEach(list -> list.removeIf(prop -> prop.name == discriminator.getPropertyName()));
+                    }
+
+                }
+            }
+        }
+        return objs;
+    }
+    private Stream<List<CodegenProperty>> getAllVarProperties(CodegenModel model) {
+        return Stream.of(model.vars, model.allVars, model.optionalVars, model.requiredVars, model.readOnlyVars, model.readWriteVars);
+    }
+
    private boolean usesRetrofit2Library() {
        return getLibrary() != null && getLibrary().contains(JVM_RETROFIT2);
    }
--- a/modules/openapi-generator/src/main/resources/kotlin-client/data_class.mustache
+++ b/modules/openapi-generator/src/main/resources/kotlin-client/data_class.mustache
@@ -40,6 +40,10 @@ import kotlinx.serialization.encoding.Encoder
 {{/enumUnknownDefaultCase}}
 {{#hasEnums}}
 {{/hasEnums}}
+{{#discriminator}}
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.JsonClassDiscriminator
+{{/discriminator}}
 {{/kotlinx_serialization}}
 {{#parcelizeModels}}
 import android.os.Parcelable
@@ -78,13 +82,21 @@ import {{packageName}}.infrastructure.ITransformForStorage
 {{#vendorExtensions.x-class-extra-annotation}}
 {{{vendorExtensions.x-class-extra-annotation}}}
 {{/vendorExtensions.x-class-extra-annotation}}
-{{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}{{#discriminator}}interface{{/discriminator}}{{^discriminator}}{{#hasVars}}data {{/hasVars}}class{{/discriminator}} {{classname}}{{^discriminator}} (
+{{#kotlinx_serialization}}{{#discriminator}}
+@OptIn(ExperimentalSerializationApi::class)
+@JsonClassDiscriminator(discriminator = "{{{discriminator.propertyName}}}")
+{{/discriminator}}
+{{#additionalProperties.discriminatorValue}}
+@SerialName(value = {{#lambda.doublequote}}{{{additionalProperties.discriminatorValue}}}{{/lambda.doublequote}})
+{{/additionalProperties.discriminatorValue}}
+{{/kotlinx_serialization}}
+{{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}{{#discriminator}}{{#kotlinx_serialization}}sealed class{{/kotlinx_serialization}}{{^kotlinx_serialization}}interface{{/kotlinx_serialization}}{{/discriminator}}{{^discriminator}}{{#hasVars}}data {{/hasVars}}class{{/discriminator}} {{classname}}{{^discriminator}} (

 {{#allVars}}
 {{#required}}{{>data_class_req_var}}{{/required}}{{^required}}{{>data_class_opt_var}}{{/required}}{{^-last}},{{/-last}}

 {{/allVars}}
-){{/discriminator}}{{#parent}}{{^serializableModel}}{{^parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#parent}}{{#serializableModel}}{{^parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}, Serializable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#parent}}{{^serializableModel}}{{#parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}, Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#parent}}{{#serializableModel}}{{#parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}, Serializable, Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{^parent}}{{#serializableModel}}{{^parcelizeModels}} : Serializable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{^parent}}{{^serializableModel}}{{#parcelizeModels}} : Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{^parent}}{{#serializableModel}}{{#parcelizeModels}} : Serializable, Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#generateRoomModels}}{{#parent}}, {{/parent}}{{^discriminator}}{{^parent}}:{{/parent}} ITransformForStorage<{{classname}}RoomModel>{{/discriminator}}{{/generateRoomModels}}{{#vendorExtensions.x-has-data-class-body}} {
+){{/discriminator}}{{#parent}}{{^serializableModel}}{{^parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#kotlinx_serialization}}(){{/kotlinx_serialization}}{{#isArray}}(){{/isArray}}{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#parent}}{{#serializableModel}}{{^parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}, Serializable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#parent}}{{^serializableModel}}{{#parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}, Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#parent}}{{#serializableModel}}{{#parcelizeModels}} : {{{parent}}}{{#isMap}}(){{/isMap}}{{#isArray}}(){{/isArray}}, Serializable, Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{^parent}}{{#serializableModel}}{{^parcelizeModels}} : Serializable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{^parent}}{{^serializableModel}}{{#parcelizeModels}} : Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{^parent}}{{#serializableModel}}{{#parcelizeModels}} : Serializable, Parcelable{{/parcelizeModels}}{{/serializableModel}}{{/parent}}{{#generateRoomModels}}{{#parent}}, {{/parent}}{{^discriminator}}{{^parent}}:{{/parent}} ITransformForStorage<{{classname}}RoomModel>{{/discriminator}}{{/generateRoomModels}}{{#vendorExtensions.x-has-data-class-body}} {
 {{/vendorExtensions.x-has-data-class-body}}
 {{#generateRoomModels}}
    companion object { }
--- a/modules/openapi-generator/src/main/resources/kotlin-client/interface_opt_var.mustache
+++ b/modules/openapi-generator/src/main/resources/kotlin-client/interface_opt_var.mustache
@@ -15,4 +15,4 @@
    {{^isEnum}}{{^isArray}}{{^isPrimitiveType}}{{^isModel}}@Contextual {{/isModel}}{{/isPrimitiveType}}{{/isArray}}{{/isEnum}}@SerialName(value = "{{{vendorExtensions.x-base-name-literal}}}")
    {{/kotlinx_serialization}}
    {{/multiplatform}}
-    {{#multiplatform}}@SerialName(value = "{{{vendorExtensions.x-base-name-literal}}}") {{/multiplatform}}{{>modelMutable}} {{{name}}}: {{#isArray}}{{#isList}}kotlin.collections.{{#modelMutable}}Mutable{{/modelMutable}}List{{/isList}}{{^isList}}kotlin.Array{{/isList}}<{{^items.isEnum}}{{^items.isPrimitiveType}}{{^items.isModel}}{{#kotlinx_serialization}}@Contextual {{/kotlinx_serialization}}{{/items.isModel}}{{/items.isPrimitiveType}}{{{items.dataType}}}{{/items.isEnum}}{{#items.isEnum}}{{classname}}.{{{nameInPascalCase}}}{{/items.isEnum}}>{{/isArray}}{{^isEnum}}{{^isArray}}{{{dataType}}}{{/isArray}}{{/isEnum}}{{#isEnum}}{{^isArray}}{{classname}}.{{{nameInPascalCase}}}{{/isArray}}{{/isEnum}}?
+    {{#multiplatform}}@SerialName(value = "{{{vendorExtensions.x-base-name-literal}}}") {{/multiplatform}}{{#kotlinx_serialization}}abstract {{/kotlinx_serialization}}{{>modelMutable}} {{{name}}}: {{#isArray}}{{#isList}}kotlin.collections.{{#modelMutable}}Mutable{{/modelMutable}}List{{/isList}}{{^isList}}kotlin.Array{{/isList}}<{{^items.isEnum}}{{^items.isPrimitiveType}}{{^items.isModel}}{{#kotlinx_serialization}}@Contextual {{/kotlinx_serialization}}{{/items.isModel}}{{/items.isPrimitiveType}}{{{items.dataType}}}{{/items.isEnum}}{{#items.isEnum}}{{classname}}.{{{nameInPascalCase}}}{{/items.isEnum}}>{{/isArray}}{{^isEnum}}{{^isArray}}{{{dataType}}}{{/isArray}}{{/isEnum}}{{#isEnum}}{{^isArray}}{{classname}}.{{{nameInPascalCase}}}{{/isArray}}{{/isEnum}}?
--- a/modules/openapi-generator/src/main/resources/kotlin-client/interface_req_var.mustache
+++ b/modules/openapi-generator/src/main/resources/kotlin-client/interface_req_var.mustache
@@ -15,4 +15,4 @@
    {{^isEnum}}{{^isArray}}{{^isPrimitiveType}}{{^isModel}}@Contextual {{/isModel}}{{/isPrimitiveType}}{{/isArray}}{{/isEnum}}@SerialName(value = "{{{vendorExtensions.x-base-name-literal}}}")
    {{/kotlinx_serialization}}
    {{/multiplatform}}
-    {{#multiplatform}}@SerialName(value = "{{{vendorExtensions.x-base-name-literal}}}") @Required {{/multiplatform}}{{>modelMutable}} {{{name}}}: {{#isArray}}{{#isList}}kotlin.collections.{{#modelMutable}}Mutable{{/modelMutable}}List{{/isList}}{{^isList}}kotlin.Array{{/isList}}<{{^items.isEnum}}{{^items.isPrimitiveType}}{{^items.isModel}}{{#kotlinx_serialization}}@Contextual {{/kotlinx_serialization}}{{/items.isModel}}{{/items.isPrimitiveType}}{{{items.dataType}}}{{/items.isEnum}}{{#items.isEnum}}{{classname}}.{{{nameInPascalCase}}}{{/items.isEnum}}>{{/isArray}}{{^isEnum}}{{^isArray}}{{{dataType}}}{{/isArray}}{{/isEnum}}{{#isEnum}}{{^isArray}}{{classname}}.{{{nameInPascalCase}}}{{/isArray}}{{/isEnum}}{{#isNullable}}?{{/isNullable}}
+    {{#multiplatform}}@SerialName(value = "{{{vendorExtensions.x-base-name-literal}}}") @Required {{/multiplatform}}{{#kotlinx_serialization}}abstract {{/kotlinx_serialization}}{{>modelMutable}} {{{name}}}: {{#isArray}}{{#isList}}kotlin.collections.{{#modelMutable}}Mutable{{/modelMutable}}List{{/isList}}{{^isList}}kotlin.Array{{/isList}}<{{^items.isEnum}}{{^items.isPrimitiveType}}{{^items.isModel}}{{#kotlinx_serialization}}@Contextual {{/kotlinx_serialization}}{{/items.isModel}}{{/items.isPrimitiveType}}{{{items.dataType}}}{{/items.isEnum}}{{#items.isEnum}}{{classname}}.{{{nameInPascalCase}}}{{/items.isEnum}}>{{/isArray}}{{^isEnum}}{{^isArray}}{{{dataType}}}{{/isArray}}{{/isEnum}}{{#isEnum}}{{^isArray}}{{classname}}.{{{nameInPascalCase}}}{{/isArray}}{{/isEnum}}{{#isNullable}}?{{/isNullable}}
--- a/modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java
+++ b/modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/KotlinClientCodegenModelTest.java
@@ -533,6 +533,46 @@ public class KotlinClientCodegenModelTest {
        Assert.assertEquals(customKotlinParseListener.getStringReferenceCount(), 0);
    }

+    @Test(description = "generate polymorphic kotlinx_serialization model")
+    public void polymorphicKotlinxSerialzation() throws IOException {
+        File output = Files.createTempDirectory("test").toFile();
+        output.deleteOnExit();
+
+        final CodegenConfigurator configurator = new CodegenConfigurator()
+                .setGeneratorName("kotlin")
+                .setLibrary("jvm-retrofit2")
+                .setAdditionalProperties(new HashMap<>() {{
+                    put(CodegenConstants.SERIALIZATION_LIBRARY, "kotlinx_serialization");
+                    put(CodegenConstants.MODEL_PACKAGE, "xyz.abcdef.model");
+                }})
+                .setInputSpec("src/test/resources/3_0/kotlin/polymorphism.yaml")
+                .setOutputDir(output.getAbsolutePath().replace("\\", "/"));
+
+        final ClientOptInput clientOptInput = configurator.toClientOptInput();
+        DefaultGenerator generator = new DefaultGenerator();
+        List<File> files = generator.opts(clientOptInput).generate();
+
+        Assert.assertEquals(files.size(), 36);
+
+        final Path animalKt = Paths.get(output + "/src/main/kotlin/xyz/abcdef/model/Animal.kt");
+        // base doesn't contain discriminator
+        TestUtils.assertFileNotContains(animalKt, "val discriminator");
+        // base is sealed class
+        TestUtils.assertFileContains(animalKt, "sealed class Animal");
+        // base properties are abstract
+        TestUtils.assertFileContains(animalKt, "abstract val id");
+        TestUtils.assertFileContains(animalKt, "abstract val optionalProperty");
+        // base has extra imports
+        TestUtils.assertFileContains(animalKt, "import kotlinx.serialization.ExperimentalSerializationApi");
+        TestUtils.assertFileContains(animalKt, "import kotlinx.serialization.json.JsonClassDiscriminator");
+
+        final Path birdKt = Paths.get(output + "/src/main/kotlin/xyz/abcdef/model/Bird.kt");
+        // derived doesn't contain disciminator
+        TestUtils.assertFileNotContains(birdKt, "val discriminator");
+        // derived has serial name set to mapping key
+        TestUtils.assertFileContains(birdKt, "@SerialName(value = \"BIRD\")");
+    }
+
    private static class ModelNameTest {
        private final String expectedName;
        private final String expectedClassName;
--- a/modules/openapi-generator/src/test/resources/3_0/kotlin/polymorphism.yaml
+++ b/modules/openapi-generator/src/test/resources/3_0/kotlin/polymorphism.yaml
@@ -0,0 +1,59 @@
+openapi: 3.0.1
+info:
+  title: Example
+  description: An example
+  version: '0.1'
+  contact:
+    email: contact@example.org
+    url: 'https://example.org'
+servers:
+  - url: http://example.org
+tags:
+  - name: bird
+paths:
+  '/v1/bird/{id}':
+    get:
+      tags:
+        - bird
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/bird'
+      operationId: get-bird
+    parameters:
+      - schema:
+          type: string
+          format: uuid
+        name: id
+        in: path
+        required: true
+components:
+  schemas:
+    animal:
+      title: An animal
+      type: object
+      properties:
+        id:
+          type: string
+          format: uuid
+        optional_property:
+          type: number
+      required:
+        - id
+      discriminator:
+        propertyName: discriminator
+        mapping:
+          BIRD: '#/components/schemas/bird'
+    bird:
+      title: A bird
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/animal'
+        - properties:
+            featherType:
+              type: string
+          required:
+            - featherType
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/.openapi-generator-ignore
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/.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
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/.openapi-generator/FILES
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/.openapi-generator/FILES
@@ -0,0 +1,35 @@
+README.md
+build.gradle
+docs/Animal.md
+docs/Bird.md
+docs/BirdApi.md
+gradle/wrapper/gradle-wrapper.jar
+gradle/wrapper/gradle-wrapper.properties
+gradlew
+gradlew.bat
+proguard-rules.pro
+settings.gradle
+src/main/kotlin/org/openapitools/client/apis/BirdApi.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ApiResponse.kt
+src/main/kotlin/org/openapitools/client/infrastructure/AtomicBooleanAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/AtomicIntegerAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/AtomicLongAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/BigDecimalAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/BigIntegerAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/Errors.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/PartConfig.kt
+src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt
+src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt
+src/main/kotlin/org/openapitools/client/infrastructure/ResponseExtensions.kt
+src/main/kotlin/org/openapitools/client/infrastructure/Serializer.kt
+src/main/kotlin/org/openapitools/client/infrastructure/StringBuilderAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/URIAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/URLAdapter.kt
+src/main/kotlin/org/openapitools/client/infrastructure/UUIDAdapter.kt
+src/main/kotlin/org/openapitools/client/models/Animal.kt
+src/main/kotlin/org/openapitools/client/models/Bird.kt
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/.openapi-generator/VERSION
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/.openapi-generator/VERSION
@@ -0,0 +1 @@
+7.15.0-SNAPSHOT
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/README.md
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/README.md
@@ -0,0 +1,68 @@
+# org.openapitools.client - Kotlin client library for Example
+
+An example
+
+## 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: 0.1
+- Package version: 
+- Generator version: 7.15.0-SNAPSHOT
+- Build package: org.openapitools.codegen.languages.KotlinClientCodegen
+For more information, please visit [https://example.org](https://example.org)
+
+## 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://example.org*
+
+| Class | Method | HTTP request | Description |
+| ------------ | ------------- | ------------- | ------------- |
+| *BirdApi* | [**getBird**](docs/BirdApi.md#getbird) | **GET** /v1/bird/{id} |  |
+
+
+<a id="documentation-for-models"></a>
+## Documentation for Models
+
+ - [org.openapitools.client.models.Animal](docs/Animal.md)
+ - [org.openapitools.client.models.Bird](docs/Bird.md)
+
+
+<a id="documentation-for-authorization"></a>
+## Documentation for Authorization
+
+Endpoints do not require authorization.
+
+
+
+## Author
+
+contact@example.org
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/build.gradle
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/build.gradle
@@ -0,0 +1,68 @@
+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.spotless_version = "6.25.0"
+
+    repositories {
+        maven { url "https://repo1.maven.org/maven2" }
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:$spotless_version"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'kotlinx-serialization'
+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-serialization-json:1.6.3"
+    implementation "com.squareup.okhttp3:okhttp:4.12.0"
+    testImplementation "io.kotlintest:kotlintest-runner-junit5:3.4.2"
+}
+
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+    kotlinOptions {
+        freeCompilerArgs += "-Xopt-in=kotlinx.serialization.ExperimentalSerializationApi"
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/docs/Animal.md
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/docs/Animal.md
@@ -0,0 +1,11 @@
+
+# Animal
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **id** | [**java.util.UUID**](java.util.UUID.md) |  |  |
+| **optionalProperty** | [**java.math.BigDecimal**](java.math.BigDecimal.md) |  |  [optional] |
+
+
+
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/docs/Bird.md
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/docs/Bird.md
@@ -0,0 +1,10 @@
+
+# Bird
+
+## Properties
+| Name | Type | Description | Notes |
+| ------------ | ------------- | ------------- | ------------- |
+| **featherType** | **kotlin.String** |  |  |
+
+
+
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/docs/BirdApi.md
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/docs/BirdApi.md
@@ -0,0 +1,53 @@
+# BirdApi
+
+All URIs are relative to *http://example.org*
+
+| Method | HTTP request | Description |
+| ------------- | ------------- | ------------- |
+| [**getBird**](BirdApi.md#getBird) | **GET** /v1/bird/{id} |  |
+
+
+<a id="getBird"></a>
+# **getBird**
+> Bird getBird(id)
+
+
+
+### Example
+```kotlin
+// Import classes:
+//import org.openapitools.client.infrastructure.*
+//import org.openapitools.client.models.*
+
+val apiInstance = BirdApi()
+val id : java.util.UUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d // java.util.UUID | 
+try {
+    val result : Bird = apiInstance.getBird(id)
+    println(result)
+} catch (e: ClientException) {
+    println("4xx response calling BirdApi#getBird")
+    e.printStackTrace()
+} catch (e: ServerException) {
+    println("5xx response calling BirdApi#getBird")
+    e.printStackTrace()
+}
+```
+
+### Parameters
+| Name | Type | Description  | Notes |
+| ------------- | ------------- | ------------- | ------------- |
+| **id** | **java.util.UUID**|  | |
+
+### Return type
+
+[**Bird**](Bird.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/gradle/wrapper/gradle-wrapper.jar
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/gradle/wrapper/gradle-wrapper.jar
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/gradle/wrapper/gradle-wrapper.properties
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/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
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/gradlew
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/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" "$@"
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/gradlew.bat
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/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
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/proguard-rules.pro
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/proguard-rules.pro
@@ -0,0 +1,11 @@
+-keepattributes *Annotation*, InnerClasses
+-dontnote kotlinx.serialization.AnnotationsKt # core serialization annotations
+
+# kotlinx-serialization-json specific. Add this if you have java.lang.NoClassDefFoundError kotlinx.serialization.json.JsonObjectSerializer
+-keepclassmembers class kotlinx.serialization.json.** { *** Companion; }
+-keepclasseswithmembers class kotlinx.serialization.json.** { kotlinx.serialization.KSerializer serializer(...); }
+
+# project specific.
+-keep,includedescriptorclasses class org.openapitools.client.models.**$$serializer { *; }
+-keepclassmembers class org.openapitools.client.models.** { *** Companion; }
+-keepclasseswithmembers class org.openapitools.client.models.** { kotlinx.serialization.KSerializer serializer(...); }
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/settings.gradle
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/settings.gradle
@@ -0,0 +1 @@
+rootProject.name = 'kotlin-allOff-discriminator'
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/apis/BirdApi.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/apis/BirdApi.kt
@@ -0,0 +1,125 @@
+/**
+ *
+ * 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 java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import org.openapitools.client.models.Bird
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import org.openapitools.client.infrastructure.ApiClient
+import org.openapitools.client.infrastructure.ApiResponse
+import org.openapitools.client.infrastructure.ClientException
+import org.openapitools.client.infrastructure.ClientError
+import org.openapitools.client.infrastructure.ServerException
+import org.openapitools.client.infrastructure.ServerError
+import org.openapitools.client.infrastructure.MultiValueMap
+import org.openapitools.client.infrastructure.PartConfig
+import org.openapitools.client.infrastructure.RequestConfig
+import org.openapitools.client.infrastructure.RequestMethod
+import org.openapitools.client.infrastructure.ResponseType
+import org.openapitools.client.infrastructure.Success
+import org.openapitools.client.infrastructure.toMultiValue
+
+class BirdApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.baseUrlKey, "http://example.org")
+        }
+    }
+
+    /**
+     * GET /v1/bird/{id}
+     * 
+     * 
+     * @param id 
+     * @return Bird
+     * @throws IllegalStateException If the request is not correctly configured
+     * @throws IOException Rethrows the OkHttp execute method exception
+     * @throws UnsupportedOperationException If the API returns an informational or redirection response
+     * @throws ClientException If the API returns a client error response
+     * @throws ServerException If the API returns a server error response
+     */
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getBird(id: java.util.UUID) : Bird {
+        val localVarResponse = getBirdWithHttpInfo(id = id)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Bird
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    /**
+     * GET /v1/bird/{id}
+     * 
+     * 
+     * @param id 
+     * @return ApiResponse<Bird?>
+     * @throws IllegalStateException If the request is not correctly configured
+     * @throws IOException Rethrows the OkHttp execute method exception
+     */
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getBirdWithHttpInfo(id: java.util.UUID) : ApiResponse<Bird?> {
+        val localVariableConfig = getBirdRequestConfig(id = id)
+
+        return request<Unit, Bird>(
+            localVariableConfig
+        )
+    }
+
+    /**
+     * To obtain the request config of the operation getBird
+     *
+     * @param id 
+     * @return RequestConfig
+     */
+    fun getBirdRequestConfig(id: java.util.UUID) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json"
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/v1/bird/{id}".replace("{"+"id"+"}", encodeURIComponent(id.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ApiAbstractions.kt
@@ -0,0 +1,23 @@
+package org.openapitools.client.infrastructure
+
+typealias MultiValueMap = MutableMap<String,List<String>>
+
+fun collectionDelimiter(collectionFormat: String): String = when(collectionFormat) {
+    "csv" -> ","
+    "tsv" -> "\t"
+    "pipe" -> "|"
+    "space" -> " "
+    else -> ""
+}
+
+val defaultMultiValueConverter: (item: Any?) -> String = { item -> "$item" }
+
+fun <T : Any?> toMultiValue(items: Array<T>, collectionFormat: String, map: (item: T) -> String = defaultMultiValueConverter): List<String>
+        = toMultiValue(items.asIterable(), collectionFormat, map)
+
+fun <T : Any?> toMultiValue(items: Iterable<T>, collectionFormat: String, map: (item: T) -> String = defaultMultiValueConverter): List<String> {
+    return when(collectionFormat) {
+        "multi" -> items.map(map)
+        else -> listOf(items.joinToString(separator = collectionDelimiter(collectionFormat), transform = map))
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ApiClient.kt
@@ -0,0 +1,361 @@
+package org.openapitools.client.infrastructure
+
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.asRequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.FormBody
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.ResponseBody
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.Request
+import okhttp3.Headers
+import okhttp3.Headers.Builder
+import okhttp3.Headers.Companion.toHeaders
+import okhttp3.MultipartBody
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.Response
+import java.io.BufferedWriter
+import java.io.File
+import java.io.FileWriter
+import java.io.IOException
+import java.net.URLConnection
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.util.Locale
+import java.util.regex.Pattern
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+
+val EMPTY_REQUEST: RequestBody = ByteArray(0).toRequestBody()
+
+open class ApiClient(val baseUrl: String, val client: Call.Factory = defaultClient) {
+    companion object {
+        protected const val ContentType: String = "Content-Type"
+        protected const val Accept: String = "Accept"
+        protected const val Authorization: String = "Authorization"
+        protected const val JsonMediaType: String = "application/json"
+        protected const val FormDataMediaType: String = "multipart/form-data"
+        protected const val FormUrlEncMediaType: String = "application/x-www-form-urlencoded"
+        protected const val XmlMediaType: String = "application/xml"
+        protected const val OctetMediaType: String = "application/octet-stream"
+        protected const val TextMediaType: String = "text/plain"
+
+        val apiKey: MutableMap<String, String> = mutableMapOf()
+        val apiKeyPrefix: MutableMap<String, String> = mutableMapOf()
+        var username: String? = null
+        var password: String? = null
+        var accessToken: String? = null
+        const val baseUrlKey: String = "org.openapitools.client.baseUrl"
+
+        @JvmStatic
+        val defaultClient: OkHttpClient by lazy {
+            builder.build()
+        }
+
+        @JvmStatic
+        val builder: OkHttpClient.Builder = OkHttpClient.Builder()
+    }
+
+    /**
+     * Guess Content-Type header from the given byteArray (defaults to "application/octet-stream").
+     *
+     * @param byteArray The given file
+     * @return The guessed Content-Type
+     */
+    protected fun guessContentTypeFromByteArray(byteArray: ByteArray): String {
+        val contentType = try {
+            URLConnection.guessContentTypeFromStream(byteArray.inputStream())
+        } catch (io: IOException) {
+            "application/octet-stream"
+        }
+        return contentType
+    }
+
+    /**
+     * Guess Content-Type header from the given file (defaults to "application/octet-stream").
+     *
+     * @param file The given file
+     * @return The guessed Content-Type
+     */
+    protected fun guessContentTypeFromFile(file: File): String {
+        val contentType = URLConnection.guessContentTypeFromName(file.name)
+        return contentType ?: "application/octet-stream"
+    }
+
+    /**
+     * Adds a File to a MultipartBody.Builder
+     * Defined a helper in the requestBody method to not duplicate code
+     * It will be used when the content is a FormDataMediaType and the body of the PartConfig is a File
+     *
+     * @param name The field name to add in the request
+     * @param headers The headers that are in the PartConfig
+     * @param file The file that will be added as the field value
+     * @return The method returns Unit but the new Part is added to the Builder that the extension function is applying on
+     * @see requestBody
+     */
+    protected fun MultipartBody.Builder.addPartToMultiPart(name: String, headers: Map<String, String>, file: File) {
+        val partHeaders = headers.toMutableMap() +
+            ("Content-Disposition" to "form-data; name=\"$name\"; filename=\"${file.name}\"")
+        val fileMediaType = guessContentTypeFromFile(file).toMediaTypeOrNull()
+        addPart(
+            partHeaders.toHeaders(),
+            file.asRequestBody(fileMediaType)
+        )
+    }
+
+    /**
+     * Adds any type to a MultipartBody.Builder
+     * Defined a helper in the requestBody method to not duplicate code
+     * It will be used when the content is a FormDataMediaType and the body of the PartConfig is not a File.
+     *
+     * @param name The field name to add in the request
+     * @param headers The headers that are in the PartConfig
+     * @param obj The field name to add in the request
+     * @return The method returns Unit but the new Part is added to the Builder that the extension function is applying on
+     * @see requestBody
+     */
+    protected fun <T> MultipartBody.Builder.addPartToMultiPart(name: String, headers: Map<String, String>, obj: T?) {
+        val partHeaders = headers.toMutableMap() +
+            ("Content-Disposition" to "form-data; name=\"$name\"")
+        addPart(
+            partHeaders.toHeaders(),
+            parameterToString(obj).toRequestBody(null)
+        )
+    }
+
+    protected inline fun <reified T> requestBody(content: T, mediaType: String?): RequestBody =
+        when {
+            content is ByteArray -> content.toRequestBody((mediaType ?: guessContentTypeFromByteArray(content)).toMediaTypeOrNull())
+            content is File -> content.asRequestBody((mediaType ?: guessContentTypeFromFile(content)).toMediaTypeOrNull())
+            mediaType == FormDataMediaType ->
+                MultipartBody.Builder()
+                    .setType(MultipartBody.FORM)
+                    .apply {
+                        // content's type *must* be Map<String, PartConfig<*>>
+                        @Suppress("UNCHECKED_CAST")
+                        (content as Map<String, PartConfig<*>>).forEach { (name, part) ->
+                            when (part.body) {
+                                is File -> addPartToMultiPart(name, part.headers, part.body)
+                                is List<*> -> {
+                                    part.body.forEach {
+                                        if (it is File) {
+                                            addPartToMultiPart(name, part.headers, it)
+                                        } else {
+                                            addPartToMultiPart(name, part.headers, it)
+                                        }
+                                    }
+                               }
+                               else -> addPartToMultiPart(name, part.headers, part.body)
+                            }
+                        }
+                    }.build()
+            mediaType == FormUrlEncMediaType -> {
+                FormBody.Builder().apply {
+                    // content's type *must* be Map<String, PartConfig<*>>
+                    @Suppress("UNCHECKED_CAST")
+                    (content as Map<String, PartConfig<*>>).forEach { (name, part) ->
+                        add(name, parameterToString(part.body))
+                    }
+                }.build()
+            }
+            mediaType == null || mediaType.startsWith("application/") && mediaType.endsWith("json") ->
+                if (content == null) {
+                    EMPTY_REQUEST
+                } else {
+                    Serializer.kotlinxSerializationJson.encodeToString(content)
+                        .toRequestBody((mediaType ?: JsonMediaType).toMediaTypeOrNull())
+                }
+            mediaType == XmlMediaType -> throw UnsupportedOperationException("xml not currently supported.")
+            mediaType == TextMediaType && content is String ->
+                content.toRequestBody(TextMediaType.toMediaTypeOrNull())
+            // TODO: this should be extended with other serializers
+            else -> throw UnsupportedOperationException("requestBody currently only supports JSON body, text body, byte body and File body.")
+        }
+
+    protected inline fun <reified T: Any?> responseBody(response: Response, mediaType: String? = JsonMediaType): T? {
+        val body = response.body
+        if(body == null) {
+            return null
+        } else if (T::class.java == Unit::class.java) {
+            // No need to parse the body when we're not interested in the body
+            // Useful when API is returning other Content-Type
+            return null
+        } else if (T::class.java == File::class.java) {
+            // return tempFile
+            val contentDisposition = response.header("Content-Disposition")
+
+            val fileName = if (contentDisposition != null) {
+                // Get filename from the Content-Disposition header.
+                val pattern = Pattern.compile("filename=['\"]?([^'\"\\s]+)['\"]?")
+                val matcher = pattern.matcher(contentDisposition)
+                if (matcher.find()) {
+                    matcher.group(1)
+                        ?.replace(".*[/\\\\]", "")
+                        ?.replace(";", "")
+                } else {
+                    null
+                }
+            } else {
+                null
+            }
+
+            var prefix: String?
+            val suffix: String?
+            if (fileName == null) {
+                prefix = "download"
+                suffix = ""
+            } else {
+                val pos = fileName.lastIndexOf(".")
+                if (pos == -1) {
+                    prefix = fileName
+                    suffix = null
+                } else {
+                    prefix = fileName.substring(0, pos)
+                    suffix = fileName.substring(pos)
+                }
+                // Files.createTempFile requires the prefix to be at least three characters long
+                if (prefix.length < 3) {
+                    prefix = "download"
+                }
+            }
+
+            // Attention: if you are developing an android app that supports API Level 25 and below, please check flag supportAndroidApiLevel25AndBelow in https://openapi-generator.tech/docs/generators/kotlin#config-options
+            val tempFile = java.nio.file.Files.createTempFile(prefix, suffix).toFile()
+            tempFile.deleteOnExit()
+            body.byteStream().use { inputStream ->
+                tempFile.outputStream().use { tempFileOutputStream ->
+                    inputStream.copyTo(tempFileOutputStream)
+                }
+            }
+            return tempFile as T
+        }
+
+        return when {
+            mediaType == null || (mediaType.startsWith("application/") && mediaType.endsWith("json")) -> {
+                val bodyContent = body.string()
+                if (bodyContent.isEmpty()) {
+                    return null
+                }
+                Serializer.kotlinxSerializationJson.decodeFromString<T>(bodyContent)
+            }
+            mediaType == OctetMediaType -> body.bytes() as? T
+            mediaType == TextMediaType -> body.string() as? T
+            else ->  throw UnsupportedOperationException("responseBody currently only supports JSON body, text body and byte body.")
+        }
+    }
+
+
+    protected inline fun <reified I, reified T: Any?> request(requestConfig: RequestConfig<I>): ApiResponse<T?> {
+        val httpUrl = baseUrl.toHttpUrlOrNull() ?: throw IllegalStateException("baseUrl is invalid.")
+
+        val url = httpUrl.newBuilder()
+            .addEncodedPathSegments(requestConfig.path.trimStart('/'))
+            .apply {
+                requestConfig.query.forEach { query ->
+                    query.value.forEach { queryValue ->
+                        addQueryParameter(query.key, queryValue)
+                    }
+                }
+            }.build()
+
+        // take content-type/accept from spec or set to default (application/json) if not defined
+        if (requestConfig.body != null && requestConfig.headers[ContentType].isNullOrEmpty()) {
+            requestConfig.headers[ContentType] = JsonMediaType
+        }
+        if (requestConfig.headers[Accept].isNullOrEmpty()) {
+            requestConfig.headers[Accept] = JsonMediaType
+        }
+        val headers = requestConfig.headers
+
+        if (headers[Accept].isNullOrEmpty()) {
+            throw kotlin.IllegalStateException("Missing Accept header. This is required.")
+        }
+
+        val contentType = if (headers[ContentType] != null) {
+            // TODO: support multiple contentType options here.
+            (headers[ContentType] as String).substringBefore(";").lowercase(Locale.US)
+        } else {
+            null
+        }
+
+        val request = when (requestConfig.method) {
+            RequestMethod.DELETE -> Request.Builder().url(url).delete(requestBody(requestConfig.body, contentType))
+            RequestMethod.GET -> Request.Builder().url(url)
+            RequestMethod.HEAD -> Request.Builder().url(url).head()
+            RequestMethod.PATCH -> Request.Builder().url(url).patch(requestBody(requestConfig.body, contentType))
+            RequestMethod.PUT -> Request.Builder().url(url).put(requestBody(requestConfig.body, contentType))
+            RequestMethod.POST -> Request.Builder().url(url).post(requestBody(requestConfig.body, contentType))
+            RequestMethod.OPTIONS -> Request.Builder().url(url).method("OPTIONS", null)
+        }.apply {
+            val headersBuilder = Headers.Builder()
+            headers.forEach { header ->
+                headersBuilder.add(header.key, header.value)
+            }
+            this.headers(headersBuilder.build())
+        }.build()
+
+        val response = client.newCall(request).execute()
+
+        val accept = response.header(ContentType)?.substringBefore(";")?.lowercase(Locale.US)
+
+        // TODO: handle specific mapping types. e.g. Map<int, Class<?>>
+        @Suppress("UNNECESSARY_SAFE_CALL")
+        return response.use {
+            when {
+                it.isRedirect -> Redirection(
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                it.isInformational -> Informational(
+                    it.message,
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                it.isSuccessful -> Success(
+                    responseBody(it, accept),
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                it.isClientError -> ClientError(
+                    it.message,
+                    it.body?.string(),
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                else -> ServerError(
+                    it.message,
+                    it.body?.string(),
+                    it.code,
+                    it.headers.toMultimap()
+                )
+            }
+        }
+    }
+
+    protected fun parameterToString(value: Any?): String = when (value) {
+        null -> ""
+        is Array<*> -> toMultiValue(value, "csv").toString()
+        is Iterable<*> -> toMultiValue(value, "csv").toString()
+        is OffsetDateTime -> parseDateToQueryString(value)
+        is OffsetTime -> parseDateToQueryString(value)
+        is LocalDateTime -> parseDateToQueryString(value)
+        is LocalDate -> parseDateToQueryString(value)
+        is LocalTime -> parseDateToQueryString(value)
+        else -> value.toString()
+    }
+
+    protected inline fun <reified T: Any> parseDateToQueryString(value : T): String {
+        /*
+        .replace("\"", "") converts the json object string to an actual string for the query parameter.
+        The moshi or gson adapter allows a more generic solution instead of trying to use a native
+        formatter. It also easily allows to provide a simple way to define a custom date format pattern
+        inside a gson/moshi adapter.
+        */
+        return Serializer.kotlinxSerializationJson.encodeToString(value).replace("\"", "")
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ApiResponse.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ApiResponse.kt
@@ -0,0 +1,43 @@
+package org.openapitools.client.infrastructure
+
+enum class ResponseType {
+    Success, Informational, Redirection, ClientError, ServerError
+}
+
+interface Response
+
+abstract class ApiResponse<T>(val responseType: ResponseType): Response {
+    abstract val statusCode: Int
+    abstract val headers: Map<String,List<String>>
+}
+
+class Success<T>(
+    val data: T,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+): ApiResponse<T>(ResponseType.Success)
+
+class Informational<T>(
+    val statusText: String,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+) : ApiResponse<T>(ResponseType.Informational)
+
+class Redirection<T>(
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+) : ApiResponse<T>(ResponseType.Redirection)
+
+class ClientError<T>(
+    val message: String? = null,
+    val body: Any? = null,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+) : ApiResponse<T>(ResponseType.ClientError)
+
+class ServerError<T>(
+    val message: String? = null,
+    val body: Any? = null,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+): ApiResponse<T>(ResponseType.ServerError)
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/AtomicBooleanAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/AtomicBooleanAdapter.kt
@@ -0,0 +1,19 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.concurrent.atomic.AtomicBoolean
+
+object AtomicBooleanAdapter : KSerializer<AtomicBoolean> {
+    override fun serialize(encoder: Encoder, value: AtomicBoolean) {
+        encoder.encodeBoolean(value.get())
+    }
+
+    override fun deserialize(decoder: Decoder): AtomicBoolean = AtomicBoolean(decoder.decodeBoolean())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AtomicBoolean", PrimitiveKind.BOOLEAN)
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/AtomicIntegerAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/AtomicIntegerAdapter.kt
@@ -0,0 +1,19 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.concurrent.atomic.AtomicInteger
+
+object AtomicIntegerAdapter : KSerializer<AtomicInteger> {
+    override fun serialize(encoder: Encoder, value: AtomicInteger) {
+        encoder.encodeInt(value.get())
+    }
+
+    override fun deserialize(decoder: Decoder): AtomicInteger = AtomicInteger(decoder.decodeInt())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AtomicInteger", PrimitiveKind.INT)
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/AtomicLongAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/AtomicLongAdapter.kt
@@ -0,0 +1,19 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.concurrent.atomic.AtomicLong
+
+object AtomicLongAdapter : KSerializer<AtomicLong> {
+    override fun serialize(encoder: Encoder, value: AtomicLong) {
+        encoder.encodeLong(value.get())
+    }
+
+    override fun deserialize(decoder: Decoder): AtomicLong = AtomicLong(decoder.decodeLong())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AtomicLong", PrimitiveKind.LONG)
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/BigDecimalAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/BigDecimalAdapter.kt
@@ -0,0 +1,15 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.math.BigDecimal
+
+object BigDecimalAdapter : KSerializer<BigDecimal> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BigDecimal", PrimitiveKind.STRING)
+    override fun deserialize(decoder: Decoder): BigDecimal = BigDecimal(decoder.decodeString())
+    override fun serialize(encoder: Encoder, value: BigDecimal) = encoder.encodeString(value.toPlainString())
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/BigIntegerAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/BigIntegerAdapter.kt
@@ -0,0 +1,20 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.math.BigInteger
+
+object BigIntegerAdapter : KSerializer<BigInteger> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BigInteger", PrimitiveKind.STRING)
+    override fun deserialize(decoder: Decoder): BigInteger {
+        return BigInteger(decoder.decodeString())
+    }
+
+    override fun serialize(encoder: Encoder, value: BigInteger) {
+        encoder.encodeString(value.toString())
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/Errors.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/Errors.kt
@@ -0,0 +1,18 @@
+@file:Suppress("unused")
+package org.openapitools.client.infrastructure
+
+import java.lang.RuntimeException
+
+open class ClientException(message: kotlin.String? = null, val statusCode: Int = -1, val response: Response? = null) : RuntimeException(message) {
+
+    companion object {
+        private const val serialVersionUID: Long = 123L
+    }
+}
+
+open class ServerException(message: kotlin.String? = null, val statusCode: Int = -1, val response: Response? = null) : RuntimeException(message) {
+
+    companion object {
+        private const val serialVersionUID: Long = 456L
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/LocalDateAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/LocalDateAdapter.kt
@@ -0,0 +1,22 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+object LocalDateAdapter : KSerializer<LocalDate> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("LocalDate", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: LocalDate) {
+        encoder.encodeString(DateTimeFormatter.ISO_LOCAL_DATE.format(value))
+    }
+
+    override fun deserialize(decoder: Decoder): LocalDate {
+        return LocalDate.parse(decoder.decodeString(), DateTimeFormatter.ISO_LOCAL_DATE)
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/LocalDateTimeAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/LocalDateTimeAdapter.kt
@@ -0,0 +1,22 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+
+object LocalDateTimeAdapter : KSerializer<LocalDateTime> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: LocalDateTime) {
+        encoder.encodeString(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(value))
+    }
+
+    override fun deserialize(decoder: Decoder): LocalDateTime {
+        return LocalDateTime.parse(decoder.decodeString(), DateTimeFormatter.ISO_LOCAL_DATE_TIME)
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/OffsetDateTimeAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/OffsetDateTimeAdapter.kt
@@ -0,0 +1,22 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+
+object OffsetDateTimeAdapter : KSerializer<OffsetDateTime> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("OffsetDateTime", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: OffsetDateTime) {
+        encoder.encodeString(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(value))
+    }
+
+    override fun deserialize(decoder: Decoder): OffsetDateTime {
+        return OffsetDateTime.parse(decoder.decodeString(), DateTimeFormatter.ISO_OFFSET_DATE_TIME)
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/PartConfig.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/PartConfig.kt
@@ -0,0 +1,11 @@
+package org.openapitools.client.infrastructure
+
+/**
+ * Defines a config object for a given part of a multi-part request.
+ * NOTE: Headers is a Map<String,String> because rfc2616 defines
+ *       multi-valued headers as csv-only.
+ */
+data class PartConfig<T>(
+    val headers: MutableMap<String, String> = mutableMapOf(),
+    val body: T? = null
+)
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/RequestConfig.kt
@@ -0,0 +1,19 @@
+package org.openapitools.client.infrastructure
+
+/**
+ * Defines a config object for a given request.
+ * NOTE: This object doesn't include 'body' because it
+ *       allows for caching of the constructed object
+ *       for many request definitions.
+ * NOTE: Headers is a Map<String,String> because rfc2616 defines
+ *       multi-valued headers as csv-only.
+ */
+data class RequestConfig<T>(
+    val method: RequestMethod,
+    val path: String,
+    val headers: MutableMap<String, String> = mutableMapOf(),
+    val params: MutableMap<String, Any> = mutableMapOf(),
+    val query: MutableMap<String, List<String>> = mutableMapOf(),
+    val requiresAuthentication: Boolean,
+    val body: T? = null
+)
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/RequestMethod.kt
@@ -0,0 +1,8 @@
+package org.openapitools.client.infrastructure
+
+/**
+ * Provides enumerated HTTP verbs
+ */
+enum class RequestMethod {
+    GET, DELETE, HEAD, OPTIONS, PATCH, POST, PUT
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ResponseExtensions.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/ResponseExtensions.kt
@@ -0,0 +1,24 @@
+package org.openapitools.client.infrastructure
+
+import okhttp3.Response
+
+/**
+ * Provides an extension to evaluation whether the response is a 1xx code
+ */
+val Response.isInformational : Boolean get() = this.code in 100..199
+
+/**
+ * Provides an extension to evaluation whether the response is a 3xx code
+ */
+@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
+val Response.isRedirect : Boolean get() = this.code in 300..399
+
+/**
+ * Provides an extension to evaluation whether the response is a 4xx code
+ */
+val Response.isClientError : Boolean get() = this.code in 400..499
+
+/**
+ * Provides an extension to evaluation whether the response is a 5xx (Standard) through 999 (non-standard) code
+ */
+val Response.isServerError : Boolean get() = this.code in 500..999
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/Serializer.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/Serializer.kt
@@ -0,0 +1,83 @@
+package org.openapitools.client.infrastructure
+
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.OffsetDateTime
+import java.util.UUID
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonBuilder
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.modules.SerializersModuleBuilder
+import java.net.URI
+import java.net.URL
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+
+object Serializer {
+    @Deprecated("Use Serializer.kotlinxSerializationAdapters instead", replaceWith = ReplaceWith("Serializer.kotlinxSerializationAdapters"), level = DeprecationLevel.ERROR)
+    @JvmStatic
+    val kotlinSerializationAdapters: SerializersModule
+        get() { return kotlinxSerializationAdapters }
+
+    private var isAdaptersInitialized = false
+
+    @JvmStatic
+    val kotlinxSerializationAdapters: SerializersModule by lazy {
+        isAdaptersInitialized = true
+        SerializersModule {
+            contextual(BigDecimal::class, BigDecimalAdapter)
+            contextual(BigInteger::class, BigIntegerAdapter)
+            contextual(LocalDate::class, LocalDateAdapter)
+            contextual(LocalDateTime::class, LocalDateTimeAdapter)
+            contextual(OffsetDateTime::class, OffsetDateTimeAdapter)
+            contextual(UUID::class, UUIDAdapter)
+            contextual(AtomicInteger::class, AtomicIntegerAdapter)
+            contextual(AtomicLong::class, AtomicLongAdapter)
+            contextual(AtomicBoolean::class, AtomicBooleanAdapter)
+            contextual(URI::class, URIAdapter)
+            contextual(URL::class, URLAdapter)
+            contextual(StringBuilder::class, StringBuilderAdapter)
+
+            apply(kotlinxSerializationAdaptersConfiguration)
+        }
+    }
+
+    var kotlinxSerializationAdaptersConfiguration: SerializersModuleBuilder.() -> Unit = {}
+        set(value) {
+            check(!isAdaptersInitialized) {
+                "Cannot configure kotlinxSerializationAdaptersConfiguration after kotlinxSerializationAdapters has been initialized."
+            }
+            field = value
+        }
+
+    @Deprecated("Use Serializer.kotlinxSerializationJson instead", replaceWith = ReplaceWith("Serializer.kotlinxSerializationJson"), level = DeprecationLevel.ERROR)
+    @JvmStatic
+    val jvmJson: Json
+        get() { return kotlinxSerializationJson }
+
+    private var isJsonInitialized = false
+
+    @JvmStatic
+    val kotlinxSerializationJson: Json by lazy {
+        isJsonInitialized = true
+        Json {
+            serializersModule = kotlinxSerializationAdapters
+            encodeDefaults = true
+            ignoreUnknownKeys = true
+            isLenient = true
+
+            apply(kotlinxSerializationJsonConfiguration)
+        }
+    }
+
+    var kotlinxSerializationJsonConfiguration: JsonBuilder.() -> Unit = {}
+        set(value) {
+            check(!isJsonInitialized) {
+                "Cannot configure kotlinxSerializationJsonConfiguration after kotlinxSerializationJson has been initialized."
+            }
+            field = value
+        }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/StringBuilderAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/StringBuilderAdapter.kt
@@ -0,0 +1,18 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+
+object StringBuilderAdapter : KSerializer<StringBuilder> {
+    override fun serialize(encoder: Encoder, value: StringBuilder) {
+        encoder.encodeString(value.toString())
+    }
+
+    override fun deserialize(decoder: Decoder): StringBuilder = StringBuilder(decoder.decodeString())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("StringBuilder", PrimitiveKind.STRING)
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/URIAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/URIAdapter.kt
@@ -0,0 +1,19 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.net.URI
+
+object URIAdapter : KSerializer<URI> {
+    override fun serialize(encoder: Encoder, value: URI) {
+        encoder.encodeString(value.toASCIIString())
+    }
+
+    override fun deserialize(decoder: Decoder): URI = URI(decoder.decodeString())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("URI", PrimitiveKind.STRING)
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/URLAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/URLAdapter.kt
@@ -0,0 +1,19 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.net.URL
+
+object URLAdapter : KSerializer<URL> {
+    override fun serialize(encoder: Encoder, value: URL) {
+        encoder.encodeString(value.toExternalForm())
+    }
+
+    override fun deserialize(decoder: Decoder): URL = URL(decoder.decodeString())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("URL", PrimitiveKind.STRING)
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/UUIDAdapter.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/infrastructure/UUIDAdapter.kt
@@ -0,0 +1,21 @@
+package org.openapitools.client.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.UUID
+
+object UUIDAdapter : KSerializer<UUID> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("UUID", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: UUID) {
+        encoder.encodeString(value.toString())
+    }
+
+    override fun deserialize(decoder: Decoder): UUID {
+        return UUID.fromString(decoder.decodeString())
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/models/Animal.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/models/Animal.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 kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.JsonClassDiscriminator
+
+/**
+ * 
+ *
+ * @param id 
+ * @param optionalProperty 
+ */
+@Serializable
+
+
+@OptIn(ExperimentalSerializationApi::class)
+@JsonClassDiscriminator(discriminator = "discriminator")
+sealed class Animal {
+
+    @Contextual @SerialName(value = "id")
+    abstract val id: java.util.UUID
+    @Contextual @SerialName(value = "optional_property")
+    abstract val optionalProperty: java.math.BigDecimal?
+
+}
+
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/models/Bird.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/main/kotlin/org/openapitools/client/models/Bird.kt
@@ -0,0 +1,54 @@
+/**
+ *
+ * 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.Animal
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+/**
+ * 
+ *
+ * @param id 
+ * @param featherType 
+ * @param optionalProperty 
+ */
+@Serializable
+
+@SerialName(value = "BIRD")
+data class Bird (
+
+    @Contextual @SerialName(value = "id")
+    override val id: java.util.UUID,
+
+    @SerialName(value = "featherType")
+    val featherType: kotlin.String,
+
+    @Contextual @SerialName(value = "optional_property")
+    override val optionalProperty: java.math.BigDecimal? = null
+
+) : Animal() {
+
+
+}
+
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/test/kotlin/org/openapitools/client/apis/BirdApiTest.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/test/kotlin/org/openapitools/client/apis/BirdApiTest.kt
@@ -0,0 +1,38 @@
+/**
+ *
+ * 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.BirdApi
+import org.openapitools.client.models.Bird
+
+class BirdApiTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of BirdApi
+        //val apiInstance = BirdApi()
+
+        // to test getBird
+        should("test getBird") {
+            // uncomment below to test getBird
+            //val id : java.util.UUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d // java.util.UUID | 
+            //val result : Bird = apiInstance.getBird(id)
+            //result shouldBe ("TODO")
+        }
+
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/test/kotlin/org/openapitools/client/models/AnimalTest.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/test/kotlin/org/openapitools/client/models/AnimalTest.kt
@@ -0,0 +1,35 @@
+/**
+ *
+ * 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.Animal
+
+class AnimalTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of Animal
+        //val modelInstance = Animal()
+
+        // to test the property `id`
+        should("test id") {
+            // uncomment below to test the property
+            //modelInstance.id shouldBe ("TODO")
+        }
+
+    }
+}
--- a/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/test/kotlin/org/openapitools/client/models/BirdTest.kt
+++ b/samples/client/petstore/kotlin-allOff-discriminator-kotlinx-serialization/src/test/kotlin/org/openapitools/client/models/BirdTest.kt
@@ -0,0 +1,36 @@
+/**
+ *
+ * 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.Bird
+import org.openapitools.client.models.Animal
+
+class BirdTest : ShouldSpec() {
+    init {
+        // uncomment below to create an instance of Bird
+        //val modelInstance = Bird()
+
+        // to test the property `featherType`
+        should("test featherType") {
+            // uncomment below to test the property
+            //modelInstance.featherType shouldBe ("TODO")
+        }
+
+    }
+}
				`@@ -0,0 +1 @@`
				`rootProject.name = 'kotlin-allOff-discriminator'`