[typescript-fetch] add samples of nullable enum (#7754)

* [typescript-fetch] add sample

* [typescript-fetch] add sample for nullable enums

bin/configs/typescript-fetch-default-v3.0.yaml

@@ -0,0 +1,3 @@
+generatorName: typescript-fetch
+outputDir: samples/client/petstore/typescript-fetch/builds/default-v3.0
+inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore-with-fake-endpoints-models-for-testing.yaml

bin/configs/typescript-fetch-enum.yaml

@@ -0,0 +1,3 @@
+generatorName: typescript-fetch
+outputDir: samples/client/petstore/typescript-fetch/builds/enum
+inputSpec: modules/openapi-generator/src/test/resources/3_0/typescript-fetch/enum.yaml

modules/openapi-generator/src/test/resources/3_0/typescript-fetch/enum.yaml

@@ -0,0 +1,229 @@
+openapi: 3.0.0
+info:
+  version: 1.0.0
+  title: Enum test
+servers:
+  - url: http://localhost:3000
+paths:
+  /fake/enum-request-ref:
+    get:
+      operationId: fake-enum-request-get-ref
+      parameters:
+        - name: string-enum
+          in: query
+          schema:
+            $ref: "#/components/schemas/StringEnum"
+        - name: nullable-string-enum
+          in: query
+          schema:
+            nullable: true
+            allOf:
+              - $ref: "#/components/schemas/StringEnum"
+        - name: number-enum
+          in: query
+          schema:
+            $ref: "#/components/schemas/NumberEnum"
+        - name: nullable-number-enum
+          in: query
+          schema:
+            nullable: true
+            allOf:
+              - $ref: "#/components/schemas/NumberEnum"
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/EnumPatternObject'
+    post:
+      operationId: fake-enum-request-post-ref
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/EnumPatternObject'
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/EnumPatternObject"
+  /fake/enum-request-inline:
+    get:
+      operationId: fake-enum-request-get-inline
+      parameters:
+        - name: string-enum
+          in: query
+          schema:
+            type: string
+            enum:
+              - one
+              - two
+              - three
+        - name: nullable-string-enum
+          in: query
+          schema:
+            nullable: true
+            allOf:
+            - type: string
+              enum:
+                - one
+                - two
+                - three
+        - name: number-enum
+          in: query
+          schema:
+            type: number
+            enum:
+              - 1
+              - 2
+              - 3
+        - name: nullable-number-enum
+          in: query
+          schema:
+            nullable: true
+            allOf:
+            - type: number
+              enum:
+                - 1
+                - 2
+                - 3
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  string-enum:
+                    type: string
+                    enum:
+                      - one
+                      - two
+                      - three
+                  nullable-string-enum:
+                    nullable: true
+                    allOf:
+                      - type: string
+                        enum:
+                          - one
+                          - two
+                          - three
+                  number-enum:
+                    type: number
+                    enum:
+                      - 1
+                      - 2
+                      - 3
+                  nullable-number-enum:
+                    nullable: true
+                    allOf:
+                    - type: number
+                      enum:
+                        - 1
+                        - 2
+                        - 3
+    post:
+      operationId: fake-enum-request-post-inline
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  string-enum:
+                    type: string
+                    enum:
+                      - one
+                      - two
+                      - three
+                  nullable-string-enum:
+                    nullable: true
+                    allOf:
+                      - type: string
+                        enum:
+                          - one
+                          - two
+                          - three
+                  number-enum:
+                    type: number
+                    enum:
+                      - 1
+                      - 2
+                      - 3
+                  nullable-number-enum:
+                    nullable: true
+                    allOf:
+                    - type: number
+                      enum:
+                        - 1
+                        - 2
+                        - 3
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                string-enum:
+                  type: string
+                  enum:
+                    - one
+                    - two
+                    - three
+                nullable-string-enum:
+                  nullable: true
+                  allOf:
+                    - type: string
+                      enum:
+                        - one
+                        - two
+                        - three
+                number-enum:
+                  type: number
+                  enum:
+                    - 1
+                    - 2
+                    - 3
+                nullable-number-enum:
+                  nullable: true
+                  allOf:
+                  - type: number
+                    enum:
+                      - 1
+                      - 2
+                      - 3
+components:
+  schemas:
+    StringEnum:
+      type: string
+      enum:
+        - one
+        - two
+        - three
+    NumberEnum:
+      type: number
+      enum:
+        - 1
+        - 2
+        - 3
+    EnumPatternObject:
+      type: object
+      properties:
+        string-enum:
+          $ref: "#/components/schemas/StringEnum"
+        nullable-string-enum:
+          nullable: true
+          allOf:
+            - $ref: "#/components/schemas/StringEnum"
+        number-enum:
+          $ref: "#/components/schemas/NumberEnum"
+        nullable-number-enum:
+          nullable: true
+          allOf:
+            - $ref: "#/components/schemas/NumberEnum"

samples/client/petstore/typescript-fetch/builds/default-v3.0/.openapi-generator-ignore

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

samples/client/petstore/typescript-fetch/builds/default-v3.0/.openapi-generator/FILES

@@ -0,0 +1,60 @@
+apis/AnotherFakeApi.ts
+apis/DefaultApi.ts
+apis/FakeApi.ts
+apis/FakeClassnameTags123Api.ts
+apis/PetApi.ts
+apis/StoreApi.ts
+apis/UserApi.ts
+apis/index.ts
+index.ts
+models/AdditionalPropertiesClass.ts
+models/Animal.ts
+models/ArrayOfArrayOfNumberOnly.ts
+models/ArrayOfNumberOnly.ts
+models/ArrayTest.ts
+models/Capitalization.ts
+models/Cat.ts
+models/CatAllOf.ts
+models/Category.ts
+models/ClassModel.ts
+models/Client.ts
+models/Dog.ts
+models/DogAllOf.ts
+models/EnumArrays.ts
+models/EnumClass.ts
+models/EnumTest.ts
+models/FileSchemaTestClass.ts
+models/Foo.ts
+models/FormatTest.ts
+models/HasOnlyReadOnly.ts
+models/HealthCheckResult.ts
+models/InlineObject.ts
+models/InlineObject1.ts
+models/InlineObject2.ts
+models/InlineObject3.ts
+models/InlineObject4.ts
+models/InlineObject5.ts
+models/InlineResponseDefault.ts
+models/List.ts
+models/MapTest.ts
+models/MixedPropertiesAndAdditionalPropertiesClass.ts
+models/Model200Response.ts
+models/ModelApiResponse.ts
+models/ModelFile.ts
+models/Name.ts
+models/NullableClass.ts
+models/NumberOnly.ts
+models/Order.ts
+models/OuterComposite.ts
+models/OuterEnum.ts
+models/OuterEnumDefaultValue.ts
+models/OuterEnumInteger.ts
+models/OuterEnumIntegerDefaultValue.ts
+models/Pet.ts
+models/ReadOnlyFirst.ts
+models/Return.ts
+models/SpecialModelName.ts
+models/Tag.ts
+models/User.ts
+models/index.ts
+runtime.ts

samples/client/petstore/typescript-fetch/builds/default-v3.0/.openapi-generator/VERSION

@@ -0,0 +1 @@
+5.0.0-SNAPSHOT

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/AnotherFakeApi.ts

@@ -0,0 +1,67 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    Client,
+    ClientFromJSON,
+    ClientToJSON,
+} from '../models';
+
+export interface 123testSpecialTagsRequest {
+    client: Client;
+}
+
+/**
+ * 
+ */
+export class AnotherFakeApi extends runtime.BaseAPI {
+
+    /**
+     * To test special tags and operation ID starting with number
+     * To test special tags
+     */
+    async _123testSpecialTagsRaw(requestParameters: 123testSpecialTagsRequest): Promise<runtime.ApiResponse<Client>> {
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling _123testSpecialTags.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/another-fake/dummy`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientToJSON(requestParameters.client),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientFromJSON(jsonValue));
+    }
+
+    /**
+     * To test special tags and operation ID starting with number
+     * To test special tags
+     */
+    async _123testSpecialTags(requestParameters: 123testSpecialTagsRequest): Promise<Client> {
+        const response = await this._123testSpecialTagsRaw(requestParameters);
+        return await response.value();
+    }
+
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/DefaultApi.ts

@@ -0,0 +1,52 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    InlineResponseDefault,
+    InlineResponseDefaultFromJSON,
+    InlineResponseDefaultToJSON,
+} from '../models';
+
+/**
+ * 
+ */
+export class DefaultApi extends runtime.BaseAPI {
+
+    /**
+     */
+    async fooGetRaw(): Promise<runtime.ApiResponse<InlineResponseDefault>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/foo`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => InlineResponseDefaultFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async fooGet(): Promise<InlineResponseDefault> {
+        const response = await this.fooGetRaw();
+        return await response.value();
+    }
+
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/FakeApi.ts

@@ -0,0 +1,904 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    Client,
+    ClientFromJSON,
+    ClientToJSON,
+    FileSchemaTestClass,
+    FileSchemaTestClassFromJSON,
+    FileSchemaTestClassToJSON,
+    HealthCheckResult,
+    HealthCheckResultFromJSON,
+    HealthCheckResultToJSON,
+    OuterComposite,
+    OuterCompositeFromJSON,
+    OuterCompositeToJSON,
+    Pet,
+    PetFromJSON,
+    PetToJSON,
+    User,
+    UserFromJSON,
+    UserToJSON,
+} from '../models';
+
+export interface FakeHttpSignatureTestRequest {
+    pet: Pet;
+    query1?: string;
+    header1?: string;
+}
+
+export interface FakeOuterBooleanSerializeRequest {
+    body?: boolean;
+}
+
+export interface FakeOuterCompositeSerializeRequest {
+    outerComposite?: OuterComposite;
+}
+
+export interface FakeOuterNumberSerializeRequest {
+    body?: number;
+}
+
+export interface FakeOuterStringSerializeRequest {
+    body?: string;
+}
+
+export interface TestBodyWithFileSchemaRequest {
+    fileSchemaTestClass: FileSchemaTestClass;
+}
+
+export interface TestBodyWithQueryParamsRequest {
+    query: string;
+    user: User;
+}
+
+export interface TestClientModelRequest {
+    client: Client;
+}
+
+export interface TestEndpointParametersRequest {
+    number: number;
+    _double: number;
+    patternWithoutDelimiter: string;
+    _byte: string;
+    integer?: number;
+    int32?: number;
+    int64?: number;
+    _float?: number;
+    string?: string;
+    binary?: Blob;
+    date?: Date;
+    dateTime?: Date;
+    password?: string;
+    callback?: string;
+}
+
+export interface TestEnumParametersRequest {
+    enumHeaderStringArray?: Array<TestEnumParametersEnumHeaderStringArrayEnum>;
+    enumHeaderString?: TestEnumParametersEnumHeaderStringEnum;
+    enumQueryStringArray?: Array<TestEnumParametersEnumQueryStringArrayEnum>;
+    enumQueryString?: TestEnumParametersEnumQueryStringEnum;
+    enumQueryInteger?: TestEnumParametersEnumQueryIntegerEnum;
+    enumQueryDouble?: TestEnumParametersEnumQueryDoubleEnum;
+    enumFormStringArray?: Array<TestEnumParametersEnumFormStringArrayEnum>;
+    enumFormString?: TestEnumParametersEnumFormStringEnum;
+}
+
+export interface TestGroupParametersRequest {
+    requiredStringGroup: number;
+    requiredBooleanGroup: boolean;
+    requiredInt64Group: number;
+    stringGroup?: number;
+    booleanGroup?: boolean;
+    int64Group?: number;
+}
+
+export interface TestInlineAdditionalPropertiesRequest {
+    requestBody: { [key: string]: string; };
+}
+
+export interface TestJsonFormDataRequest {
+    param: string;
+    param2: string;
+}
+
+export interface TestQueryParameterCollectionFormatRequest {
+    pipe: Array<string>;
+    ioutil: Array<string>;
+    http: Array<string>;
+    url: Array<string>;
+    context: Array<string>;
+}
+
+/**
+ * 
+ */
+export class FakeApi extends runtime.BaseAPI {
+
+    /**
+     * Health check endpoint
+     */
+    async fakeHealthGetRaw(): Promise<runtime.ApiResponse<HealthCheckResult>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/fake/health`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => HealthCheckResultFromJSON(jsonValue));
+    }
+
+    /**
+     * Health check endpoint
+     */
+    async fakeHealthGet(): Promise<HealthCheckResult> {
+        const response = await this.fakeHealthGetRaw();
+        return await response.value();
+    }
+
+    /**
+     * test http signature authentication
+     */
+    async fakeHttpSignatureTestRaw(requestParameters: FakeHttpSignatureTestRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.pet === null || requestParameters.pet === undefined) {
+            throw new runtime.RequiredError('pet','Required parameter requestParameters.pet was null or undefined when calling fakeHttpSignatureTest.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.query1 !== undefined) {
+            queryParameters['query_1'] = requestParameters.query1;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters.header1 !== undefined && requestParameters.header1 !== null) {
+            headerParameters['header_1'] = String(requestParameters.header1);
+        }
+
+        const response = await this.request({
+            path: `/fake/http-signature-test`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PetToJSON(requestParameters.pet),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * test http signature authentication
+     */
+    async fakeHttpSignatureTest(requestParameters: FakeHttpSignatureTestRequest): Promise<void> {
+        await this.fakeHttpSignatureTestRaw(requestParameters);
+    }
+
+    /**
+     * Test serialization of outer boolean types
+     */
+    async fakeOuterBooleanSerializeRaw(requestParameters: FakeOuterBooleanSerializeRequest): Promise<runtime.ApiResponse<boolean>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/outer/boolean`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.body as any,
+        });
+
+        return new runtime.TextApiResponse(response) as any;
+    }
+
+    /**
+     * Test serialization of outer boolean types
+     */
+    async fakeOuterBooleanSerialize(requestParameters: FakeOuterBooleanSerializeRequest): Promise<boolean> {
+        const response = await this.fakeOuterBooleanSerializeRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Test serialization of object with outer number type
+     */
+    async fakeOuterCompositeSerializeRaw(requestParameters: FakeOuterCompositeSerializeRequest): Promise<runtime.ApiResponse<OuterComposite>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/outer/composite`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OuterCompositeToJSON(requestParameters.outerComposite),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OuterCompositeFromJSON(jsonValue));
+    }
+
+    /**
+     * Test serialization of object with outer number type
+     */
+    async fakeOuterCompositeSerialize(requestParameters: FakeOuterCompositeSerializeRequest): Promise<OuterComposite> {
+        const response = await this.fakeOuterCompositeSerializeRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Test serialization of outer number types
+     */
+    async fakeOuterNumberSerializeRaw(requestParameters: FakeOuterNumberSerializeRequest): Promise<runtime.ApiResponse<number>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/outer/number`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.body as any,
+        });
+
+        return new runtime.TextApiResponse(response) as any;
+    }
+
+    /**
+     * Test serialization of outer number types
+     */
+    async fakeOuterNumberSerialize(requestParameters: FakeOuterNumberSerializeRequest): Promise<number> {
+        const response = await this.fakeOuterNumberSerializeRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Test serialization of outer string types
+     */
+    async fakeOuterStringSerializeRaw(requestParameters: FakeOuterStringSerializeRequest): Promise<runtime.ApiResponse<string>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/outer/string`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.body as any,
+        });
+
+        return new runtime.TextApiResponse(response) as any;
+    }
+
+    /**
+     * Test serialization of outer string types
+     */
+    async fakeOuterStringSerialize(requestParameters: FakeOuterStringSerializeRequest): Promise<string> {
+        const response = await this.fakeOuterStringSerializeRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * For this test, the body for this request much reference a schema named `File`.
+     */
+    async testBodyWithFileSchemaRaw(requestParameters: TestBodyWithFileSchemaRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.fileSchemaTestClass === null || requestParameters.fileSchemaTestClass === undefined) {
+            throw new runtime.RequiredError('fileSchemaTestClass','Required parameter requestParameters.fileSchemaTestClass was null or undefined when calling testBodyWithFileSchema.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/body-with-file-schema`,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: FileSchemaTestClassToJSON(requestParameters.fileSchemaTestClass),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * For this test, the body for this request much reference a schema named `File`.
+     */
+    async testBodyWithFileSchema(requestParameters: TestBodyWithFileSchemaRequest): Promise<void> {
+        await this.testBodyWithFileSchemaRaw(requestParameters);
+    }
+
+    /**
+     */
+    async testBodyWithQueryParamsRaw(requestParameters: TestBodyWithQueryParamsRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.query === null || requestParameters.query === undefined) {
+            throw new runtime.RequiredError('query','Required parameter requestParameters.query was null or undefined when calling testBodyWithQueryParams.');
+        }
+
+        if (requestParameters.user === null || requestParameters.user === undefined) {
+            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling testBodyWithQueryParams.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.query !== undefined) {
+            queryParameters['query'] = requestParameters.query;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/body-with-query-params`,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: UserToJSON(requestParameters.user),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async testBodyWithQueryParams(requestParameters: TestBodyWithQueryParamsRequest): Promise<void> {
+        await this.testBodyWithQueryParamsRaw(requestParameters);
+    }
+
+    /**
+     * To test \"client\" model
+     * To test \"client\" model
+     */
+    async testClientModelRaw(requestParameters: TestClientModelRequest): Promise<runtime.ApiResponse<Client>> {
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling testClientModel.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientToJSON(requestParameters.client),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientFromJSON(jsonValue));
+    }
+
+    /**
+     * To test \"client\" model
+     * To test \"client\" model
+     */
+    async testClientModel(requestParameters: TestClientModelRequest): Promise<Client> {
+        const response = await this.testClientModelRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     */
+    async testEndpointParametersRaw(requestParameters: TestEndpointParametersRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.number === null || requestParameters.number === undefined) {
+            throw new runtime.RequiredError('number','Required parameter requestParameters.number was null or undefined when calling testEndpointParameters.');
+        }
+
+        if (requestParameters._double === null || requestParameters._double === undefined) {
+            throw new runtime.RequiredError('_double','Required parameter requestParameters._double was null or undefined when calling testEndpointParameters.');
+        }
+
+        if (requestParameters.patternWithoutDelimiter === null || requestParameters.patternWithoutDelimiter === undefined) {
+            throw new runtime.RequiredError('patternWithoutDelimiter','Required parameter requestParameters.patternWithoutDelimiter was null or undefined when calling testEndpointParameters.');
+        }
+
+        if (requestParameters._byte === null || requestParameters._byte === undefined) {
+            throw new runtime.RequiredError('_byte','Required parameter requestParameters._byte was null or undefined when calling testEndpointParameters.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && (this.configuration.username !== undefined || this.configuration.password !== undefined)) {
+            headerParameters["Authorization"] = "Basic " + btoa(this.configuration.username + ":" + this.configuration.password);
+        }
+        const consumes: runtime.Consume[] = [
+            { contentType: 'application/x-www-form-urlencoded' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        // use FormData to transmit files using content-type "multipart/form-data"
+        useForm = canConsumeForm;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters.integer !== undefined) {
+            formParams.append('integer', requestParameters.integer as any);
+        }
+
+        if (requestParameters.int32 !== undefined) {
+            formParams.append('int32', requestParameters.int32 as any);
+        }
+
+        if (requestParameters.int64 !== undefined) {
+            formParams.append('int64', requestParameters.int64 as any);
+        }
+
+        if (requestParameters.number !== undefined) {
+            formParams.append('number', requestParameters.number as any);
+        }
+
+        if (requestParameters._float !== undefined) {
+            formParams.append('float', requestParameters._float as any);
+        }
+
+        if (requestParameters._double !== undefined) {
+            formParams.append('double', requestParameters._double as any);
+        }
+
+        if (requestParameters.string !== undefined) {
+            formParams.append('string', requestParameters.string as any);
+        }
+
+        if (requestParameters.patternWithoutDelimiter !== undefined) {
+            formParams.append('pattern_without_delimiter', requestParameters.patternWithoutDelimiter as any);
+        }
+
+        if (requestParameters._byte !== undefined) {
+            formParams.append('byte', requestParameters._byte as any);
+        }
+
+        if (requestParameters.binary !== undefined) {
+            formParams.append('binary', requestParameters.binary as any);
+        }
+
+        if (requestParameters.date !== undefined) {
+            formParams.append('date', requestParameters.date as any);
+        }
+
+        if (requestParameters.dateTime !== undefined) {
+            formParams.append('dateTime', requestParameters.dateTime as any);
+        }
+
+        if (requestParameters.password !== undefined) {
+            formParams.append('password', requestParameters.password as any);
+        }
+
+        if (requestParameters.callback !== undefined) {
+            formParams.append('callback', requestParameters.callback as any);
+        }
+
+        const response = await this.request({
+            path: `/fake`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
+     */
+    async testEndpointParameters(requestParameters: TestEndpointParametersRequest): Promise<void> {
+        await this.testEndpointParametersRaw(requestParameters);
+    }
+
+    /**
+     * To test enum parameters
+     * To test enum parameters
+     */
+    async testEnumParametersRaw(requestParameters: TestEnumParametersRequest): Promise<runtime.ApiResponse<void>> {
+        const queryParameters: any = {};
+
+        if (requestParameters.enumQueryStringArray) {
+            queryParameters['enum_query_string_array'] = requestParameters.enumQueryStringArray;
+        }
+
+        if (requestParameters.enumQueryString !== undefined) {
+            queryParameters['enum_query_string'] = requestParameters.enumQueryString;
+        }
+
+        if (requestParameters.enumQueryInteger !== undefined) {
+            queryParameters['enum_query_integer'] = requestParameters.enumQueryInteger;
+        }
+
+        if (requestParameters.enumQueryDouble !== undefined) {
+            queryParameters['enum_query_double'] = requestParameters.enumQueryDouble;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters.enumHeaderStringArray) {
+            headerParameters['enum_header_string_array'] = requestParameters.enumHeaderStringArray.join(runtime.COLLECTION_FORMATS["csv"]);
+        }
+
+        if (requestParameters.enumHeaderString !== undefined && requestParameters.enumHeaderString !== null) {
+            headerParameters['enum_header_string'] = String(requestParameters.enumHeaderString);
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'application/x-www-form-urlencoded' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters.enumFormStringArray) {
+            formParams.append('enum_form_string_array', requestParameters.enumFormStringArray.join(runtime.COLLECTION_FORMATS["csv"]));
+        }
+
+        if (requestParameters.enumFormString !== undefined) {
+            formParams.append('enum_form_string', requestParameters.enumFormString as any);
+        }
+
+        const response = await this.request({
+            path: `/fake`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * To test enum parameters
+     * To test enum parameters
+     */
+    async testEnumParameters(requestParameters: TestEnumParametersRequest): Promise<void> {
+        await this.testEnumParametersRaw(requestParameters);
+    }
+
+    /**
+     * Fake endpoint to test group parameters (optional)
+     * Fake endpoint to test group parameters (optional)
+     */
+    async testGroupParametersRaw(requestParameters: TestGroupParametersRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.requiredStringGroup === null || requestParameters.requiredStringGroup === undefined) {
+            throw new runtime.RequiredError('requiredStringGroup','Required parameter requestParameters.requiredStringGroup was null or undefined when calling testGroupParameters.');
+        }
+
+        if (requestParameters.requiredBooleanGroup === null || requestParameters.requiredBooleanGroup === undefined) {
+            throw new runtime.RequiredError('requiredBooleanGroup','Required parameter requestParameters.requiredBooleanGroup was null or undefined when calling testGroupParameters.');
+        }
+
+        if (requestParameters.requiredInt64Group === null || requestParameters.requiredInt64Group === undefined) {
+            throw new runtime.RequiredError('requiredInt64Group','Required parameter requestParameters.requiredInt64Group was null or undefined when calling testGroupParameters.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.requiredStringGroup !== undefined) {
+            queryParameters['required_string_group'] = requestParameters.requiredStringGroup;
+        }
+
+        if (requestParameters.requiredInt64Group !== undefined) {
+            queryParameters['required_int64_group'] = requestParameters.requiredInt64Group;
+        }
+
+        if (requestParameters.stringGroup !== undefined) {
+            queryParameters['string_group'] = requestParameters.stringGroup;
+        }
+
+        if (requestParameters.int64Group !== undefined) {
+            queryParameters['int64_group'] = requestParameters.int64Group;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters.requiredBooleanGroup !== undefined && requestParameters.requiredBooleanGroup !== null) {
+            headerParameters['required_boolean_group'] = String(requestParameters.requiredBooleanGroup);
+        }
+
+        if (requestParameters.booleanGroup !== undefined && requestParameters.booleanGroup !== null) {
+            headerParameters['boolean_group'] = String(requestParameters.booleanGroup);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = typeof token === 'function' ? token("bearer_test", []) : token;
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/fake`,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Fake endpoint to test group parameters (optional)
+     * Fake endpoint to test group parameters (optional)
+     */
+    async testGroupParameters(requestParameters: TestGroupParametersRequest): Promise<void> {
+        await this.testGroupParametersRaw(requestParameters);
+    }
+
+    /**
+     * test inline additionalProperties
+     */
+    async testInlineAdditionalPropertiesRaw(requestParameters: TestInlineAdditionalPropertiesRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.requestBody === null || requestParameters.requestBody === undefined) {
+            throw new runtime.RequiredError('requestBody','Required parameter requestParameters.requestBody was null or undefined when calling testInlineAdditionalProperties.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/inline-additionalProperties`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.requestBody,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * test inline additionalProperties
+     */
+    async testInlineAdditionalProperties(requestParameters: TestInlineAdditionalPropertiesRequest): Promise<void> {
+        await this.testInlineAdditionalPropertiesRaw(requestParameters);
+    }
+
+    /**
+     * test json serialization of form data
+     */
+    async testJsonFormDataRaw(requestParameters: TestJsonFormDataRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.param === null || requestParameters.param === undefined) {
+            throw new runtime.RequiredError('param','Required parameter requestParameters.param was null or undefined when calling testJsonFormData.');
+        }
+
+        if (requestParameters.param2 === null || requestParameters.param2 === undefined) {
+            throw new runtime.RequiredError('param2','Required parameter requestParameters.param2 was null or undefined when calling testJsonFormData.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'application/x-www-form-urlencoded' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters.param !== undefined) {
+            formParams.append('param', requestParameters.param as any);
+        }
+
+        if (requestParameters.param2 !== undefined) {
+            formParams.append('param2', requestParameters.param2 as any);
+        }
+
+        const response = await this.request({
+            path: `/fake/jsonFormData`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * test json serialization of form data
+     */
+    async testJsonFormData(requestParameters: TestJsonFormDataRequest): Promise<void> {
+        await this.testJsonFormDataRaw(requestParameters);
+    }
+
+    /**
+     * To test the collection format in query parameters
+     */
+    async testQueryParameterCollectionFormatRaw(requestParameters: TestQueryParameterCollectionFormatRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.pipe === null || requestParameters.pipe === undefined) {
+            throw new runtime.RequiredError('pipe','Required parameter requestParameters.pipe was null or undefined when calling testQueryParameterCollectionFormat.');
+        }
+
+        if (requestParameters.ioutil === null || requestParameters.ioutil === undefined) {
+            throw new runtime.RequiredError('ioutil','Required parameter requestParameters.ioutil was null or undefined when calling testQueryParameterCollectionFormat.');
+        }
+
+        if (requestParameters.http === null || requestParameters.http === undefined) {
+            throw new runtime.RequiredError('http','Required parameter requestParameters.http was null or undefined when calling testQueryParameterCollectionFormat.');
+        }
+
+        if (requestParameters.url === null || requestParameters.url === undefined) {
+            throw new runtime.RequiredError('url','Required parameter requestParameters.url was null or undefined when calling testQueryParameterCollectionFormat.');
+        }
+
+        if (requestParameters.context === null || requestParameters.context === undefined) {
+            throw new runtime.RequiredError('context','Required parameter requestParameters.context was null or undefined when calling testQueryParameterCollectionFormat.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.pipe) {
+            queryParameters['pipe'] = requestParameters.pipe;
+        }
+
+        if (requestParameters.ioutil) {
+            queryParameters['ioutil'] = requestParameters.ioutil.join(runtime.COLLECTION_FORMATS["csv"]);
+        }
+
+        if (requestParameters.http) {
+            queryParameters['http'] = requestParameters.http.join(runtime.COLLECTION_FORMATS["ssv"]);
+        }
+
+        if (requestParameters.url) {
+            queryParameters['url'] = requestParameters.url.join(runtime.COLLECTION_FORMATS["csv"]);
+        }
+
+        if (requestParameters.context) {
+            queryParameters['context'] = requestParameters.context;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/fake/test-query-paramters`,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * To test the collection format in query parameters
+     */
+    async testQueryParameterCollectionFormat(requestParameters: TestQueryParameterCollectionFormatRequest): Promise<void> {
+        await this.testQueryParameterCollectionFormatRaw(requestParameters);
+    }
+
+}
+
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumHeaderStringArrayEnum {
+    GreaterThan = '>',
+    Dollar = '$'
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumHeaderStringEnum {
+    Abc = '_abc',
+    Efg = '-efg',
+    Xyz = '(xyz)'
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumQueryStringArrayEnum {
+    GreaterThan = '>',
+    Dollar = '$'
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumQueryStringEnum {
+    Abc = '_abc',
+    Efg = '-efg',
+    Xyz = '(xyz)'
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumQueryIntegerEnum {
+    NUMBER_1 = 1,
+    NUMBER_MINUS_2 = -2
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumQueryDoubleEnum {
+    NUMBER_1_DOT_1 = 1.1,
+    NUMBER_MINUS_1_DOT_2 = -1.2
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumFormStringArrayEnum {
+    GreaterThan = '>',
+    Dollar = '$'
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum TestEnumParametersEnumFormStringEnum {
+    Abc = '_abc',
+    Efg = '-efg',
+    Xyz = '(xyz)'
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/FakeClassnameTags123Api.ts

@@ -0,0 +1,71 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    Client,
+    ClientFromJSON,
+    ClientToJSON,
+} from '../models';
+
+export interface TestClassnameRequest {
+    client: Client;
+}
+
+/**
+ * 
+ */
+export class FakeClassnameTags123Api extends runtime.BaseAPI {
+
+    /**
+     * To test class name in snake case
+     * To test class name in snake case
+     */
+    async testClassnameRaw(requestParameters: TestClassnameRequest): Promise<runtime.ApiResponse<Client>> {
+        if (requestParameters.client === null || requestParameters.client === undefined) {
+            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling testClassname.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            queryParameters["api_key_query"] = this.configuration.apiKey("api_key_query"); // api_key_query authentication
+        }
+
+        const response = await this.request({
+            path: `/fake_classname_test`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientToJSON(requestParameters.client),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientFromJSON(jsonValue));
+    }
+
+    /**
+     * To test class name in snake case
+     * To test class name in snake case
+     */
+    async testClassname(requestParameters: TestClassnameRequest): Promise<Client> {
+        const response = await this.testClassnameRaw(requestParameters);
+        return await response.value();
+    }
+
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/PetApi.ts

@@ -0,0 +1,527 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    ModelApiResponse,
+    ModelApiResponseFromJSON,
+    ModelApiResponseToJSON,
+    Pet,
+    PetFromJSON,
+    PetToJSON,
+} from '../models';
+
+export interface AddPetRequest {
+    pet: Pet;
+}
+
+export interface DeletePetRequest {
+    petId: number;
+    apiKey?: string;
+}
+
+export interface FindPetsByStatusRequest {
+    status: Array<FindPetsByStatusStatusEnum>;
+}
+
+export interface FindPetsByTagsRequest {
+    tags: Array<string>;
+}
+
+export interface GetPetByIdRequest {
+    petId: number;
+}
+
+export interface UpdatePetRequest {
+    pet: Pet;
+}
+
+export interface UpdatePetWithFormRequest {
+    petId: number;
+    name?: string;
+    status?: string;
+}
+
+export interface UploadFileRequest {
+    petId: number;
+    additionalMetadata?: string;
+    file?: Blob;
+}
+
+export interface UploadFileWithRequiredFileRequest {
+    petId: number;
+    requiredFile: Blob;
+    additionalMetadata?: string;
+}
+
+/**
+ * 
+ */
+export class PetApi extends runtime.BaseAPI {
+
+    /**
+     * Add a new pet to the store
+     */
+    async addPetRaw(requestParameters: AddPetRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.pet === null || requestParameters.pet === undefined) {
+            throw new runtime.RequiredError('pet','Required parameter requestParameters.pet was null or undefined when calling addPet.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const response = await this.request({
+            path: `/pet`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PetToJSON(requestParameters.pet),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Add a new pet to the store
+     */
+    async addPet(requestParameters: AddPetRequest): Promise<void> {
+        await this.addPetRaw(requestParameters);
+    }
+
+    /**
+     * Deletes a pet
+     */
+    async deletePetRaw(requestParameters: DeletePetRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.petId === null || requestParameters.petId === undefined) {
+            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
+            headerParameters['api_key'] = String(requestParameters.apiKey);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const response = await this.request({
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Deletes a pet
+     */
+    async deletePet(requestParameters: DeletePetRequest): Promise<void> {
+        await this.deletePetRaw(requestParameters);
+    }
+
+    /**
+     * Multiple status values can be provided with comma separated strings
+     * Finds Pets by status
+     */
+    async findPetsByStatusRaw(requestParameters: FindPetsByStatusRequest): Promise<runtime.ApiResponse<Array<Pet>>> {
+        if (requestParameters.status === null || requestParameters.status === undefined) {
+            throw new runtime.RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.status) {
+            queryParameters['status'] = requestParameters.status.join(runtime.COLLECTION_FORMATS["csv"]);
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const response = await this.request({
+            path: `/pet/findByStatus`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PetFromJSON));
+    }
+
+    /**
+     * Multiple status values can be provided with comma separated strings
+     * Finds Pets by status
+     */
+    async findPetsByStatus(requestParameters: FindPetsByStatusRequest): Promise<Array<Pet>> {
+        const response = await this.findPetsByStatusRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     * Finds Pets by tags
+     */
+    async findPetsByTagsRaw(requestParameters: FindPetsByTagsRequest): Promise<runtime.ApiResponse<Array<Pet>>> {
+        if (requestParameters.tags === null || requestParameters.tags === undefined) {
+            throw new runtime.RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.tags) {
+            queryParameters['tags'] = requestParameters.tags.join(runtime.COLLECTION_FORMATS["csv"]);
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const response = await this.request({
+            path: `/pet/findByTags`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PetFromJSON));
+    }
+
+    /**
+     * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+     * Finds Pets by tags
+     */
+    async findPetsByTags(requestParameters: FindPetsByTagsRequest): Promise<Array<Pet>> {
+        const response = await this.findPetsByTagsRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Returns a single pet
+     * Find pet by ID
+     */
+    async getPetByIdRaw(requestParameters: GetPetByIdRequest): Promise<runtime.ApiResponse<Pet>> {
+        if (requestParameters.petId === null || requestParameters.petId === undefined) {
+            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
+        }
+
+        const response = await this.request({
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PetFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns a single pet
+     * Find pet by ID
+     */
+    async getPetById(requestParameters: GetPetByIdRequest): Promise<Pet> {
+        const response = await this.getPetByIdRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Update an existing pet
+     */
+    async updatePetRaw(requestParameters: UpdatePetRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.pet === null || requestParameters.pet === undefined) {
+            throw new runtime.RequiredError('pet','Required parameter requestParameters.pet was null or undefined when calling updatePet.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const response = await this.request({
+            path: `/pet`,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PetToJSON(requestParameters.pet),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update an existing pet
+     */
+    async updatePet(requestParameters: UpdatePetRequest): Promise<void> {
+        await this.updatePetRaw(requestParameters);
+    }
+
+    /**
+     * Updates a pet in the store with form data
+     */
+    async updatePetWithFormRaw(requestParameters: UpdatePetWithFormRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.petId === null || requestParameters.petId === undefined) {
+            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'application/x-www-form-urlencoded' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters.name !== undefined) {
+            formParams.append('name', requestParameters.name as any);
+        }
+
+        if (requestParameters.status !== undefined) {
+            formParams.append('status', requestParameters.status as any);
+        }
+
+        const response = await this.request({
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Updates a pet in the store with form data
+     */
+    async updatePetWithForm(requestParameters: UpdatePetWithFormRequest): Promise<void> {
+        await this.updatePetWithFormRaw(requestParameters);
+    }
+
+    /**
+     * uploads an image
+     */
+    async uploadFileRaw(requestParameters: UploadFileRequest): Promise<runtime.ApiResponse<ModelApiResponse>> {
+        if (requestParameters.petId === null || requestParameters.petId === undefined) {
+            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        // use FormData to transmit files using content-type "multipart/form-data"
+        useForm = canConsumeForm;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters.additionalMetadata !== undefined) {
+            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        }
+
+        if (requestParameters.file !== undefined) {
+            formParams.append('file', requestParameters.file as any);
+        }
+
+        const response = await this.request({
+            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ModelApiResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * uploads an image
+     */
+    async uploadFile(requestParameters: UploadFileRequest): Promise<ModelApiResponse> {
+        const response = await this.uploadFileRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * uploads an image (required)
+     */
+    async uploadFileWithRequiredFileRaw(requestParameters: UploadFileWithRequiredFileRequest): Promise<runtime.ApiResponse<ModelApiResponse>> {
+        if (requestParameters.petId === null || requestParameters.petId === undefined) {
+            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFileWithRequiredFile.');
+        }
+
+        if (requestParameters.requiredFile === null || requestParameters.requiredFile === undefined) {
+            throw new runtime.RequiredError('requiredFile','Required parameter requestParameters.requiredFile was null or undefined when calling uploadFileWithRequiredFile.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            // oauth required
+            if (typeof this.configuration.accessToken === 'function') {
+                headerParameters["Authorization"] = this.configuration.accessToken("petstore_auth", ["write:pets", "read:pets"]);
+            } else {
+                headerParameters["Authorization"] = this.configuration.accessToken;
+            }
+        }
+
+        const consumes: runtime.Consume[] = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+
+        let formParams: { append(param: string, value: any): any };
+        let useForm = false;
+        // use FormData to transmit files using content-type "multipart/form-data"
+        useForm = canConsumeForm;
+        if (useForm) {
+            formParams = new FormData();
+        } else {
+            formParams = new URLSearchParams();
+        }
+
+        if (requestParameters.additionalMetadata !== undefined) {
+            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        }
+
+        if (requestParameters.requiredFile !== undefined) {
+            formParams.append('requiredFile', requestParameters.requiredFile as any);
+        }
+
+        const response = await this.request({
+            path: `/fake/{petId}/uploadImageWithRequiredFile`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: formParams,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ModelApiResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * uploads an image (required)
+     */
+    async uploadFileWithRequiredFile(requestParameters: UploadFileWithRequiredFileRequest): Promise<ModelApiResponse> {
+        const response = await this.uploadFileWithRequiredFileRaw(requestParameters);
+        return await response.value();
+    }
+
+}
+
+/**
+    * @export
+    * @enum {string}
+    */
+export enum FindPetsByStatusStatusEnum {
+    Available = 'available',
+    Pending = 'pending',
+    Sold = 'sold'
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/StoreApi.ts

@@ -0,0 +1,168 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    Order,
+    OrderFromJSON,
+    OrderToJSON,
+} from '../models';
+
+export interface DeleteOrderRequest {
+    orderId: string;
+}
+
+export interface GetOrderByIdRequest {
+    orderId: number;
+}
+
+export interface PlaceOrderRequest {
+    order: Order;
+}
+
+/**
+ * 
+ */
+export class StoreApi extends runtime.BaseAPI {
+
+    /**
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     * Delete purchase order by ID
+     */
+    async deleteOrderRaw(requestParameters: DeleteOrderRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
+            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/store/order/{order_id}`.replace(`{${"order_id"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+     * Delete purchase order by ID
+     */
+    async deleteOrder(requestParameters: DeleteOrderRequest): Promise<void> {
+        await this.deleteOrderRaw(requestParameters);
+    }
+
+    /**
+     * Returns a map of status codes to quantities
+     * Returns pet inventories by status
+     */
+    async getInventoryRaw(): Promise<runtime.ApiResponse<{ [key: string]: number; }>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["api_key"] = this.configuration.apiKey("api_key"); // api_key authentication
+        }
+
+        const response = await this.request({
+            path: `/store/inventory`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Returns a map of status codes to quantities
+     * Returns pet inventories by status
+     */
+    async getInventory(): Promise<{ [key: string]: number; }> {
+        const response = await this.getInventoryRaw();
+        return await response.value();
+    }
+
+    /**
+     * For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
+     * Find purchase order by ID
+     */
+    async getOrderByIdRaw(requestParameters: GetOrderByIdRequest): Promise<runtime.ApiResponse<Order>> {
+        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
+            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/store/order/{order_id}`.replace(`{${"order_id"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));
+    }
+
+    /**
+     * For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
+     * Find purchase order by ID
+     */
+    async getOrderById(requestParameters: GetOrderByIdRequest): Promise<Order> {
+        const response = await this.getOrderByIdRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Place an order for a pet
+     */
+    async placeOrderRaw(requestParameters: PlaceOrderRequest): Promise<runtime.ApiResponse<Order>> {
+        if (requestParameters.order === null || requestParameters.order === undefined) {
+            throw new runtime.RequiredError('order','Required parameter requestParameters.order was null or undefined when calling placeOrder.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/store/order`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OrderToJSON(requestParameters.order),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));
+    }
+
+    /**
+     * Place an order for a pet
+     */
+    async placeOrder(requestParameters: PlaceOrderRequest): Promise<Order> {
+        const response = await this.placeOrderRaw(requestParameters);
+        return await response.value();
+    }
+
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/UserApi.ts

@@ -0,0 +1,322 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    User,
+    UserFromJSON,
+    UserToJSON,
+} from '../models';
+
+export interface CreateUserRequest {
+    user: User;
+}
+
+export interface CreateUsersWithArrayInputRequest {
+    user: Array<User>;
+}
+
+export interface CreateUsersWithListInputRequest {
+    user: Array<User>;
+}
+
+export interface DeleteUserRequest {
+    username: string;
+}
+
+export interface GetUserByNameRequest {
+    username: string;
+}
+
+export interface LoginUserRequest {
+    username: string;
+    password: string;
+}
+
+export interface UpdateUserRequest {
+    username: string;
+    user: User;
+}
+
+/**
+ * 
+ */
+export class UserApi extends runtime.BaseAPI {
+
+    /**
+     * This can only be done by the logged in user.
+     * Create user
+     */
+    async createUserRaw(requestParameters: CreateUserRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.user === null || requestParameters.user === undefined) {
+            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling createUser.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/user`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: UserToJSON(requestParameters.user),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * This can only be done by the logged in user.
+     * Create user
+     */
+    async createUser(requestParameters: CreateUserRequest): Promise<void> {
+        await this.createUserRaw(requestParameters);
+    }
+
+    /**
+     * Creates list of users with given input array
+     */
+    async createUsersWithArrayInputRaw(requestParameters: CreateUsersWithArrayInputRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.user === null || requestParameters.user === undefined) {
+            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling createUsersWithArrayInput.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/user/createWithArray`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.user.map(UserToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Creates list of users with given input array
+     */
+    async createUsersWithArrayInput(requestParameters: CreateUsersWithArrayInputRequest): Promise<void> {
+        await this.createUsersWithArrayInputRaw(requestParameters);
+    }
+
+    /**
+     * Creates list of users with given input array
+     */
+    async createUsersWithListInputRaw(requestParameters: CreateUsersWithListInputRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.user === null || requestParameters.user === undefined) {
+            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling createUsersWithListInput.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/user/createWithList`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters.user.map(UserToJSON),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Creates list of users with given input array
+     */
+    async createUsersWithListInput(requestParameters: CreateUsersWithListInputRequest): Promise<void> {
+        await this.createUsersWithListInputRaw(requestParameters);
+    }
+
+    /**
+     * This can only be done by the logged in user.
+     * Delete user
+     */
+    async deleteUserRaw(requestParameters: DeleteUserRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.username === null || requestParameters.username === undefined) {
+            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * This can only be done by the logged in user.
+     * Delete user
+     */
+    async deleteUser(requestParameters: DeleteUserRequest): Promise<void> {
+        await this.deleteUserRaw(requestParameters);
+    }
+
+    /**
+     * Get user by user name
+     */
+    async getUserByNameRaw(requestParameters: GetUserByNameRequest): Promise<runtime.ApiResponse<User>> {
+        if (requestParameters.username === null || requestParameters.username === undefined) {
+            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
+    }
+
+    /**
+     * Get user by user name
+     */
+    async getUserByName(requestParameters: GetUserByNameRequest): Promise<User> {
+        const response = await this.getUserByNameRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Logs user into the system
+     */
+    async loginUserRaw(requestParameters: LoginUserRequest): Promise<runtime.ApiResponse<string>> {
+        if (requestParameters.username === null || requestParameters.username === undefined) {
+            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
+        }
+
+        if (requestParameters.password === null || requestParameters.password === undefined) {
+            throw new runtime.RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters.username !== undefined) {
+            queryParameters['username'] = requestParameters.username;
+        }
+
+        if (requestParameters.password !== undefined) {
+            queryParameters['password'] = requestParameters.password;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/user/login`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.TextApiResponse(response) as any;
+    }
+
+    /**
+     * Logs user into the system
+     */
+    async loginUser(requestParameters: LoginUserRequest): Promise<string> {
+        const response = await this.loginUserRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     * Logs out current logged in user session
+     */
+    async logoutUserRaw(): Promise<runtime.ApiResponse<void>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/user/logout`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Logs out current logged in user session
+     */
+    async logoutUser(): Promise<void> {
+        await this.logoutUserRaw();
+    }
+
+    /**
+     * This can only be done by the logged in user.
+     * Updated user
+     */
+    async updateUserRaw(requestParameters: UpdateUserRequest): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.username === null || requestParameters.username === undefined) {
+            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
+        }
+
+        if (requestParameters.user === null || requestParameters.user === undefined) {
+            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling updateUser.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: UserToJSON(requestParameters.user),
+        });
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * This can only be done by the logged in user.
+     * Updated user
+     */
+    async updateUser(requestParameters: UpdateUserRequest): Promise<void> {
+        await this.updateUserRaw(requestParameters);
+    }
+
+}

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/index.ts

@@ -0,0 +1,7 @@
+export * from './AnotherFakeApi';
+export * from './DefaultApi';
+export * from './FakeApi';
+export * from './FakeClassnameTags123Api';
+export * from './PetApi';
+export * from './StoreApi';
+export * from './UserApi';

samples/client/petstore/typescript-fetch/builds/default-v3.0/index.ts

@@ -0,0 +1,3 @@
+export * from './runtime';
+export * from './apis';
+export * from './models';

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/AdditionalPropertiesClass.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface AdditionalPropertiesClass
+ */
+export interface AdditionalPropertiesClass {
+    /**
+     * 
+     * @type {{ [key: string]: string; }}
+     * @memberof AdditionalPropertiesClass
+     */
+    mapProperty?: { [key: string]: string; };
+    /**
+     * 
+     * @type {{ [key: string]: { [key: string]: string; }; }}
+     * @memberof AdditionalPropertiesClass
+     */
+    mapOfMapProperty?: { [key: string]: { [key: string]: string; }; };
+}
+
+export function AdditionalPropertiesClassFromJSON(json: any): AdditionalPropertiesClass {
+    return AdditionalPropertiesClassFromJSONTyped(json, false);
+}
+
+export function AdditionalPropertiesClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): AdditionalPropertiesClass {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'mapProperty': !exists(json, 'map_property') ? undefined : json['map_property'],
+        'mapOfMapProperty': !exists(json, 'map_of_map_property') ? undefined : json['map_of_map_property'],
+    };
+}
+
+export function AdditionalPropertiesClassToJSON(value?: AdditionalPropertiesClass | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'map_property': value.mapProperty,
+        'map_of_map_property': value.mapOfMapProperty,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Animal.ts

@@ -0,0 +1,78 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+     DogFromJSONTyped,
+     CatFromJSONTyped
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface Animal
+ */
+export interface Animal {
+    /**
+     * 
+     * @type {string}
+     * @memberof Animal
+     */
+    className: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof Animal
+     */
+    color?: string;
+}
+
+export function AnimalFromJSON(json: any): Animal {
+    return AnimalFromJSONTyped(json, false);
+}
+
+export function AnimalFromJSONTyped(json: any, ignoreDiscriminator: boolean): Animal {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    if (!ignoreDiscriminator) {
+        if (json['className'] === 'Dog') {
+            return DogFromJSONTyped(json, true);
+        }
+        if (json['className'] === 'Cat') {
+            return CatFromJSONTyped(json, true);
+        }
+    }
+    return {
+        
+        'className': json['className'],
+        'color': !exists(json, 'color') ? undefined : json['color'],
+    };
+}
+
+export function AnimalToJSON(value?: Animal | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'className': value.className,
+        'color': value.color,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ArrayOfArrayOfNumberOnly.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ArrayOfArrayOfNumberOnly
+ */
+export interface ArrayOfArrayOfNumberOnly {
+    /**
+     * 
+     * @type {Array<Array<number>>}
+     * @memberof ArrayOfArrayOfNumberOnly
+     */
+    arrayArrayNumber?: Array<Array<number>>;
+}
+
+export function ArrayOfArrayOfNumberOnlyFromJSON(json: any): ArrayOfArrayOfNumberOnly {
+    return ArrayOfArrayOfNumberOnlyFromJSONTyped(json, false);
+}
+
+export function ArrayOfArrayOfNumberOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): ArrayOfArrayOfNumberOnly {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'arrayArrayNumber': !exists(json, 'ArrayArrayNumber') ? undefined : json['ArrayArrayNumber'],
+    };
+}
+
+export function ArrayOfArrayOfNumberOnlyToJSON(value?: ArrayOfArrayOfNumberOnly | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'ArrayArrayNumber': value.arrayArrayNumber,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ArrayOfNumberOnly.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ArrayOfNumberOnly
+ */
+export interface ArrayOfNumberOnly {
+    /**
+     * 
+     * @type {Array<number>}
+     * @memberof ArrayOfNumberOnly
+     */
+    arrayNumber?: Array<number>;
+}
+
+export function ArrayOfNumberOnlyFromJSON(json: any): ArrayOfNumberOnly {
+    return ArrayOfNumberOnlyFromJSONTyped(json, false);
+}
+
+export function ArrayOfNumberOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): ArrayOfNumberOnly {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'arrayNumber': !exists(json, 'ArrayNumber') ? undefined : json['ArrayNumber'],
+    };
+}
+
+export function ArrayOfNumberOnlyToJSON(value?: ArrayOfNumberOnly | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'ArrayNumber': value.arrayNumber,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ArrayTest.ts

@@ -0,0 +1,80 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    ReadOnlyFirst,
+    ReadOnlyFirstFromJSON,
+    ReadOnlyFirstFromJSONTyped,
+    ReadOnlyFirstToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface ArrayTest
+ */
+export interface ArrayTest {
+    /**
+     * 
+     * @type {Array<string>}
+     * @memberof ArrayTest
+     */
+    arrayOfString?: Array<string>;
+    /**
+     * 
+     * @type {Array<Array<number>>}
+     * @memberof ArrayTest
+     */
+    arrayArrayOfInteger?: Array<Array<number>>;
+    /**
+     * 
+     * @type {Array<Array<ReadOnlyFirst>>}
+     * @memberof ArrayTest
+     */
+    arrayArrayOfModel?: Array<Array<ReadOnlyFirst>>;
+}
+
+export function ArrayTestFromJSON(json: any): ArrayTest {
+    return ArrayTestFromJSONTyped(json, false);
+}
+
+export function ArrayTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): ArrayTest {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'arrayOfString': !exists(json, 'array_of_string') ? undefined : json['array_of_string'],
+        'arrayArrayOfInteger': !exists(json, 'array_array_of_integer') ? undefined : json['array_array_of_integer'],
+        'arrayArrayOfModel': !exists(json, 'array_array_of_model') ? undefined : json['array_array_of_model'],
+    };
+}
+
+export function ArrayTestToJSON(value?: ArrayTest | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'array_of_string': value.arrayOfString,
+        'array_array_of_integer': value.arrayArrayOfInteger,
+        'array_array_of_model': value.arrayArrayOfModel,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Capitalization.ts

@@ -0,0 +1,97 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Capitalization
+ */
+export interface Capitalization {
+    /**
+     * 
+     * @type {string}
+     * @memberof Capitalization
+     */
+    smallCamel?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof Capitalization
+     */
+    capitalCamel?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof Capitalization
+     */
+    smallSnake?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof Capitalization
+     */
+    capitalSnake?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof Capitalization
+     */
+    sCAETHFlowPoints?: string;
+    /**
+     * Name of the pet
+     * @type {string}
+     * @memberof Capitalization
+     */
+    aTTNAME?: string;
+}
+
+export function CapitalizationFromJSON(json: any): Capitalization {
+    return CapitalizationFromJSONTyped(json, false);
+}
+
+export function CapitalizationFromJSONTyped(json: any, ignoreDiscriminator: boolean): Capitalization {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'smallCamel': !exists(json, 'smallCamel') ? undefined : json['smallCamel'],
+        'capitalCamel': !exists(json, 'CapitalCamel') ? undefined : json['CapitalCamel'],
+        'smallSnake': !exists(json, 'small_Snake') ? undefined : json['small_Snake'],
+        'capitalSnake': !exists(json, 'Capital_Snake') ? undefined : json['Capital_Snake'],
+        'sCAETHFlowPoints': !exists(json, 'SCA_ETH_Flow_Points') ? undefined : json['SCA_ETH_Flow_Points'],
+        'aTTNAME': !exists(json, 'ATT_NAME') ? undefined : json['ATT_NAME'],
+    };
+}
+
+export function CapitalizationToJSON(value?: Capitalization | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'smallCamel': value.smallCamel,
+        'CapitalCamel': value.capitalCamel,
+        'small_Snake': value.smallSnake,
+        'Capital_Snake': value.capitalSnake,
+        'SCA_ETH_Flow_Points': value.sCAETHFlowPoints,
+        'ATT_NAME': value.aTTNAME,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Cat.ts

@@ -0,0 +1,68 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    Animal,
+    AnimalFromJSON,
+    AnimalFromJSONTyped,
+    AnimalToJSON,
+    CatAllOf,
+    CatAllOfFromJSON,
+    CatAllOfFromJSONTyped,
+    CatAllOfToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface Cat
+ */
+export interface Cat extends Animal {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof Cat
+     */
+    declawed?: boolean;
+}
+
+export function CatFromJSON(json: any): Cat {
+    return CatFromJSONTyped(json, false);
+}
+
+export function CatFromJSONTyped(json: any, ignoreDiscriminator: boolean): Cat {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        ...AnimalFromJSONTyped(json, ignoreDiscriminator),
+        'declawed': !exists(json, 'declawed') ? undefined : json['declawed'],
+    };
+}
+
+export function CatToJSON(value?: Cat | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        ...AnimalToJSON(value),
+        'declawed': value.declawed,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/CatAllOf.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface CatAllOf
+ */
+export interface CatAllOf {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof CatAllOf
+     */
+    declawed?: boolean;
+}
+
+export function CatAllOfFromJSON(json: any): CatAllOf {
+    return CatAllOfFromJSONTyped(json, false);
+}
+
+export function CatAllOfFromJSONTyped(json: any, ignoreDiscriminator: boolean): CatAllOf {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'declawed': !exists(json, 'declawed') ? undefined : json['declawed'],
+    };
+}
+
+export function CatAllOfToJSON(value?: CatAllOf | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'declawed': value.declawed,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Category.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Category
+ */
+export interface Category {
+    /**
+     * 
+     * @type {number}
+     * @memberof Category
+     */
+    id?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof Category
+     */
+    name: string;
+}
+
+export function CategoryFromJSON(json: any): Category {
+    return CategoryFromJSONTyped(json, false);
+}
+
+export function CategoryFromJSONTyped(json: any, ignoreDiscriminator: boolean): Category {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'id': !exists(json, 'id') ? undefined : json['id'],
+        'name': json['name'],
+    };
+}
+
+export function CategoryToJSON(value?: Category | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'id': value.id,
+        'name': value.name,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ClassModel.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * Model for testing model with "_class" property
+ * @export
+ * @interface ClassModel
+ */
+export interface ClassModel {
+    /**
+     * 
+     * @type {string}
+     * @memberof ClassModel
+     */
+    _class?: string;
+}
+
+export function ClassModelFromJSON(json: any): ClassModel {
+    return ClassModelFromJSONTyped(json, false);
+}
+
+export function ClassModelFromJSONTyped(json: any, ignoreDiscriminator: boolean): ClassModel {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        '_class': !exists(json, '_class') ? undefined : json['_class'],
+    };
+}
+
+export function ClassModelToJSON(value?: ClassModel | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        '_class': value._class,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Client.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Client
+ */
+export interface Client {
+    /**
+     * 
+     * @type {string}
+     * @memberof Client
+     */
+    client?: string;
+}
+
+export function ClientFromJSON(json: any): Client {
+    return ClientFromJSONTyped(json, false);
+}
+
+export function ClientFromJSONTyped(json: any, ignoreDiscriminator: boolean): Client {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'client': !exists(json, 'client') ? undefined : json['client'],
+    };
+}
+
+export function ClientToJSON(value?: Client | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'client': value.client,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Dog.ts

@@ -0,0 +1,68 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    Animal,
+    AnimalFromJSON,
+    AnimalFromJSONTyped,
+    AnimalToJSON,
+    DogAllOf,
+    DogAllOfFromJSON,
+    DogAllOfFromJSONTyped,
+    DogAllOfToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface Dog
+ */
+export interface Dog extends Animal {
+    /**
+     * 
+     * @type {string}
+     * @memberof Dog
+     */
+    breed?: string;
+}
+
+export function DogFromJSON(json: any): Dog {
+    return DogFromJSONTyped(json, false);
+}
+
+export function DogFromJSONTyped(json: any, ignoreDiscriminator: boolean): Dog {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        ...AnimalFromJSONTyped(json, ignoreDiscriminator),
+        'breed': !exists(json, 'breed') ? undefined : json['breed'],
+    };
+}
+
+export function DogToJSON(value?: Dog | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        ...AnimalToJSON(value),
+        'breed': value.breed,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/DogAllOf.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface DogAllOf
+ */
+export interface DogAllOf {
+    /**
+     * 
+     * @type {string}
+     * @memberof DogAllOf
+     */
+    breed?: string;
+}
+
+export function DogAllOfFromJSON(json: any): DogAllOf {
+    return DogAllOfFromJSONTyped(json, false);
+}
+
+export function DogAllOfFromJSONTyped(json: any, ignoreDiscriminator: boolean): DogAllOf {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'breed': !exists(json, 'breed') ? undefined : json['breed'],
+    };
+}
+
+export function DogAllOfToJSON(value?: DogAllOf | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'breed': value.breed,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/EnumArrays.ts

@@ -0,0 +1,82 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface EnumArrays
+ */
+export interface EnumArrays {
+    /**
+     * 
+     * @type {string}
+     * @memberof EnumArrays
+     */
+    justSymbol?: EnumArraysJustSymbolEnum;
+    /**
+     * 
+     * @type {Array<string>}
+     * @memberof EnumArrays
+     */
+    arrayEnum?: Array<EnumArraysArrayEnumEnum>;
+}
+
+export function EnumArraysFromJSON(json: any): EnumArrays {
+    return EnumArraysFromJSONTyped(json, false);
+}
+
+export function EnumArraysFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumArrays {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'justSymbol': !exists(json, 'just_symbol') ? undefined : json['just_symbol'],
+        'arrayEnum': !exists(json, 'array_enum') ? undefined : json['array_enum'],
+    };
+}
+
+export function EnumArraysToJSON(value?: EnumArrays | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'just_symbol': value.justSymbol,
+        'array_enum': value.arrayEnum,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum EnumArraysJustSymbolEnum {
+    GreaterThanOrEqualTo = '>=',
+    Dollar = '$'
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum EnumArraysArrayEnumEnum {
+    Fish = 'fish',
+    Crab = 'crab'
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/EnumClass.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum EnumClass {
+    Abc = '_abc',
+    Efg = '-efg',
+    Xyz = '(xyz)'
+}
+
+export function EnumClassFromJSON(json: any): EnumClass {
+    return EnumClassFromJSONTyped(json, false);
+}
+
+export function EnumClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumClass {
+    return json as EnumClass;
+}
+
+export function EnumClassToJSON(value?: EnumClass | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/EnumTest.ts

@@ -0,0 +1,167 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    OuterEnum,
+    OuterEnumFromJSON,
+    OuterEnumFromJSONTyped,
+    OuterEnumToJSON,
+    OuterEnumDefaultValue,
+    OuterEnumDefaultValueFromJSON,
+    OuterEnumDefaultValueFromJSONTyped,
+    OuterEnumDefaultValueToJSON,
+    OuterEnumInteger,
+    OuterEnumIntegerFromJSON,
+    OuterEnumIntegerFromJSONTyped,
+    OuterEnumIntegerToJSON,
+    OuterEnumIntegerDefaultValue,
+    OuterEnumIntegerDefaultValueFromJSON,
+    OuterEnumIntegerDefaultValueFromJSONTyped,
+    OuterEnumIntegerDefaultValueToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface EnumTest
+ */
+export interface EnumTest {
+    /**
+     * 
+     * @type {string}
+     * @memberof EnumTest
+     */
+    enumString?: EnumTestEnumStringEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof EnumTest
+     */
+    enumStringRequired: EnumTestEnumStringRequiredEnum;
+    /**
+     * 
+     * @type {number}
+     * @memberof EnumTest
+     */
+    enumInteger?: EnumTestEnumIntegerEnum;
+    /**
+     * 
+     * @type {number}
+     * @memberof EnumTest
+     */
+    enumNumber?: EnumTestEnumNumberEnum;
+    /**
+     * 
+     * @type {OuterEnum}
+     * @memberof EnumTest
+     */
+    outerEnum?: OuterEnum | null;
+    /**
+     * 
+     * @type {OuterEnumInteger}
+     * @memberof EnumTest
+     */
+    outerEnumInteger?: OuterEnumInteger;
+    /**
+     * 
+     * @type {OuterEnumDefaultValue}
+     * @memberof EnumTest
+     */
+    outerEnumDefaultValue?: OuterEnumDefaultValue;
+    /**
+     * 
+     * @type {OuterEnumIntegerDefaultValue}
+     * @memberof EnumTest
+     */
+    outerEnumIntegerDefaultValue?: OuterEnumIntegerDefaultValue;
+}
+
+export function EnumTestFromJSON(json: any): EnumTest {
+    return EnumTestFromJSONTyped(json, false);
+}
+
+export function EnumTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumTest {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'enumString': !exists(json, 'enum_string') ? undefined : json['enum_string'],
+        'enumStringRequired': json['enum_string_required'],
+        'enumInteger': !exists(json, 'enum_integer') ? undefined : json['enum_integer'],
+        'enumNumber': !exists(json, 'enum_number') ? undefined : json['enum_number'],
+        'outerEnum': !exists(json, 'outerEnum') ? undefined : OuterEnumFromJSON(json['outerEnum']),
+        'outerEnumInteger': !exists(json, 'outerEnumInteger') ? undefined : OuterEnumIntegerFromJSON(json['outerEnumInteger']),
+        'outerEnumDefaultValue': !exists(json, 'outerEnumDefaultValue') ? undefined : OuterEnumDefaultValueFromJSON(json['outerEnumDefaultValue']),
+        'outerEnumIntegerDefaultValue': !exists(json, 'outerEnumIntegerDefaultValue') ? undefined : OuterEnumIntegerDefaultValueFromJSON(json['outerEnumIntegerDefaultValue']),
+    };
+}
+
+export function EnumTestToJSON(value?: EnumTest | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'enum_string': value.enumString,
+        'enum_string_required': value.enumStringRequired,
+        'enum_integer': value.enumInteger,
+        'enum_number': value.enumNumber,
+        'outerEnum': OuterEnumToJSON(value.outerEnum),
+        'outerEnumInteger': OuterEnumIntegerToJSON(value.outerEnumInteger),
+        'outerEnumDefaultValue': OuterEnumDefaultValueToJSON(value.outerEnumDefaultValue),
+        'outerEnumIntegerDefaultValue': OuterEnumIntegerDefaultValueToJSON(value.outerEnumIntegerDefaultValue),
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum EnumTestEnumStringEnum {
+    Upper = 'UPPER',
+    Lower = 'lower',
+    Empty = ''
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum EnumTestEnumStringRequiredEnum {
+    Upper = 'UPPER',
+    Lower = 'lower',
+    Empty = ''
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum EnumTestEnumIntegerEnum {
+    NUMBER_1 = 1,
+    NUMBER_MINUS_1 = -1
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum EnumTestEnumNumberEnum {
+    NUMBER_1_DOT_1 = 1.1,
+    NUMBER_MINUS_1_DOT_2 = -1.2
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/FileSchemaTestClass.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface FileSchemaTestClass
+ */
+export interface FileSchemaTestClass {
+    /**
+     * 
+     * @type {any}
+     * @memberof FileSchemaTestClass
+     */
+    file?: any;
+    /**
+     * 
+     * @type {Array<any>}
+     * @memberof FileSchemaTestClass
+     */
+    files?: Array<any>;
+}
+
+export function FileSchemaTestClassFromJSON(json: any): FileSchemaTestClass {
+    return FileSchemaTestClassFromJSONTyped(json, false);
+}
+
+export function FileSchemaTestClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): FileSchemaTestClass {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'file': !exists(json, 'file') ? undefined : json['file'],
+        'files': !exists(json, 'files') ? undefined : json['files'],
+    };
+}
+
+export function FileSchemaTestClassToJSON(value?: FileSchemaTestClass | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'file': value.file,
+        'files': value.files,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Foo.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Foo
+ */
+export interface Foo {
+    /**
+     * 
+     * @type {string}
+     * @memberof Foo
+     */
+    bar?: string;
+}
+
+export function FooFromJSON(json: any): Foo {
+    return FooFromJSONTyped(json, false);
+}
+
+export function FooFromJSONTyped(json: any, ignoreDiscriminator: boolean): Foo {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'bar': !exists(json, 'bar') ? undefined : json['bar'],
+    };
+}
+
+export function FooToJSON(value?: Foo | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'bar': value.bar,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/FormatTest.ts

@@ -0,0 +1,169 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface FormatTest
+ */
+export interface FormatTest {
+    /**
+     * 
+     * @type {number}
+     * @memberof FormatTest
+     */
+    integer?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof FormatTest
+     */
+    int32?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof FormatTest
+     */
+    int64?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof FormatTest
+     */
+    number: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof FormatTest
+     */
+    _float?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof FormatTest
+     */
+    _double?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof FormatTest
+     */
+    string?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof FormatTest
+     */
+    _byte: string;
+    /**
+     * 
+     * @type {Blob}
+     * @memberof FormatTest
+     */
+    binary?: Blob;
+    /**
+     * 
+     * @type {Date}
+     * @memberof FormatTest
+     */
+    date: Date;
+    /**
+     * 
+     * @type {Date}
+     * @memberof FormatTest
+     */
+    dateTime?: Date;
+    /**
+     * 
+     * @type {string}
+     * @memberof FormatTest
+     */
+    uuid?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof FormatTest
+     */
+    password: string;
+    /**
+     * A string that is a 10 digit number. Can have leading zeros.
+     * @type {string}
+     * @memberof FormatTest
+     */
+    patternWithDigits?: string;
+    /**
+     * A string starting with 'image_' (case insensitive) and one to three digits following i.e. Image_01.
+     * @type {string}
+     * @memberof FormatTest
+     */
+    patternWithDigitsAndDelimiter?: string;
+}
+
+export function FormatTestFromJSON(json: any): FormatTest {
+    return FormatTestFromJSONTyped(json, false);
+}
+
+export function FormatTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): FormatTest {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'integer': !exists(json, 'integer') ? undefined : json['integer'],
+        'int32': !exists(json, 'int32') ? undefined : json['int32'],
+        'int64': !exists(json, 'int64') ? undefined : json['int64'],
+        'number': json['number'],
+        '_float': !exists(json, 'float') ? undefined : json['float'],
+        '_double': !exists(json, 'double') ? undefined : json['double'],
+        'string': !exists(json, 'string') ? undefined : json['string'],
+        '_byte': json['byte'],
+        'binary': !exists(json, 'binary') ? undefined : json['binary'],
+        'date': (new Date(json['date'])),
+        'dateTime': !exists(json, 'dateTime') ? undefined : (new Date(json['dateTime'])),
+        'uuid': !exists(json, 'uuid') ? undefined : json['uuid'],
+        'password': json['password'],
+        'patternWithDigits': !exists(json, 'pattern_with_digits') ? undefined : json['pattern_with_digits'],
+        'patternWithDigitsAndDelimiter': !exists(json, 'pattern_with_digits_and_delimiter') ? undefined : json['pattern_with_digits_and_delimiter'],
+    };
+}
+
+export function FormatTestToJSON(value?: FormatTest | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'integer': value.integer,
+        'int32': value.int32,
+        'int64': value.int64,
+        'number': value.number,
+        'float': value._float,
+        'double': value._double,
+        'string': value.string,
+        'byte': value._byte,
+        'binary': value.binary,
+        'date': (value.date.toISOString().substr(0,10)),
+        'dateTime': value.dateTime === undefined ? undefined : (value.dateTime.toISOString()),
+        'uuid': value.uuid,
+        'password': value.password,
+        'pattern_with_digits': value.patternWithDigits,
+        'pattern_with_digits_and_delimiter': value.patternWithDigitsAndDelimiter,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/HasOnlyReadOnly.ts

@@ -0,0 +1,63 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface HasOnlyReadOnly
+ */
+export interface HasOnlyReadOnly {
+    /**
+     * 
+     * @type {string}
+     * @memberof HasOnlyReadOnly
+     */
+    readonly bar?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof HasOnlyReadOnly
+     */
+    readonly foo?: string;
+}
+
+export function HasOnlyReadOnlyFromJSON(json: any): HasOnlyReadOnly {
+    return HasOnlyReadOnlyFromJSONTyped(json, false);
+}
+
+export function HasOnlyReadOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): HasOnlyReadOnly {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'bar': !exists(json, 'bar') ? undefined : json['bar'],
+        'foo': !exists(json, 'foo') ? undefined : json['foo'],
+    };
+}
+
+export function HasOnlyReadOnlyToJSON(value?: HasOnlyReadOnly | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/HealthCheckResult.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * Just a string to inform instance is up and running. Make it nullable in hope to get it as pointer in generated model.
+ * @export
+ * @interface HealthCheckResult
+ */
+export interface HealthCheckResult {
+    /**
+     * 
+     * @type {string}
+     * @memberof HealthCheckResult
+     */
+    nullableMessage?: string | null;
+}
+
+export function HealthCheckResultFromJSON(json: any): HealthCheckResult {
+    return HealthCheckResultFromJSONTyped(json, false);
+}
+
+export function HealthCheckResultFromJSONTyped(json: any, ignoreDiscriminator: boolean): HealthCheckResult {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'nullableMessage': !exists(json, 'NullableMessage') ? undefined : json['NullableMessage'],
+    };
+}
+
+export function HealthCheckResultToJSON(value?: HealthCheckResult | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'NullableMessage': value.nullableMessage,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineObject.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject
+ */
+export interface InlineObject {
+    /**
+     * Updated name of the pet
+     * @type {string}
+     * @memberof InlineObject
+     */
+    name?: string;
+    /**
+     * Updated status of the pet
+     * @type {string}
+     * @memberof InlineObject
+     */
+    status?: string;
+}
+
+export function InlineObjectFromJSON(json: any): InlineObject {
+    return InlineObjectFromJSONTyped(json, false);
+}
+
+export function InlineObjectFromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'name': !exists(json, 'name') ? undefined : json['name'],
+        'status': !exists(json, 'status') ? undefined : json['status'],
+    };
+}
+
+export function InlineObjectToJSON(value?: InlineObject | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'name': value.name,
+        'status': value.status,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineObject1.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject1
+ */
+export interface InlineObject1 {
+    /**
+     * Additional data to pass to server
+     * @type {string}
+     * @memberof InlineObject1
+     */
+    additionalMetadata?: string;
+    /**
+     * file to upload
+     * @type {Blob}
+     * @memberof InlineObject1
+     */
+    file?: Blob;
+}
+
+export function InlineObject1FromJSON(json: any): InlineObject1 {
+    return InlineObject1FromJSONTyped(json, false);
+}
+
+export function InlineObject1FromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject1 {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'additionalMetadata': !exists(json, 'additionalMetadata') ? undefined : json['additionalMetadata'],
+        'file': !exists(json, 'file') ? undefined : json['file'],
+    };
+}
+
+export function InlineObject1ToJSON(value?: InlineObject1 | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'additionalMetadata': value.additionalMetadata,
+        'file': value.file,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineObject2.ts

@@ -0,0 +1,83 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject2
+ */
+export interface InlineObject2 {
+    /**
+     * Form parameter enum test (string array)
+     * @type {Array<string>}
+     * @memberof InlineObject2
+     */
+    enumFormStringArray?: Array<InlineObject2EnumFormStringArrayEnum>;
+    /**
+     * Form parameter enum test (string)
+     * @type {string}
+     * @memberof InlineObject2
+     */
+    enumFormString?: InlineObject2EnumFormStringEnum;
+}
+
+export function InlineObject2FromJSON(json: any): InlineObject2 {
+    return InlineObject2FromJSONTyped(json, false);
+}
+
+export function InlineObject2FromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject2 {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'enumFormStringArray': !exists(json, 'enum_form_string_array') ? undefined : json['enum_form_string_array'],
+        'enumFormString': !exists(json, 'enum_form_string') ? undefined : json['enum_form_string'],
+    };
+}
+
+export function InlineObject2ToJSON(value?: InlineObject2 | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'enum_form_string_array': value.enumFormStringArray,
+        'enum_form_string': value.enumFormString,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum InlineObject2EnumFormStringArrayEnum {
+    GreaterThan = '>',
+    Dollar = '$'
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum InlineObject2EnumFormStringEnum {
+    Abc = '_abc',
+    Efg = '-efg',
+    Xyz = '(xyz)'
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineObject3.ts

@@ -0,0 +1,161 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject3
+ */
+export interface InlineObject3 {
+    /**
+     * None
+     * @type {number}
+     * @memberof InlineObject3
+     */
+    integer?: number;
+    /**
+     * None
+     * @type {number}
+     * @memberof InlineObject3
+     */
+    int32?: number;
+    /**
+     * None
+     * @type {number}
+     * @memberof InlineObject3
+     */
+    int64?: number;
+    /**
+     * None
+     * @type {number}
+     * @memberof InlineObject3
+     */
+    number: number;
+    /**
+     * None
+     * @type {number}
+     * @memberof InlineObject3
+     */
+    _float?: number;
+    /**
+     * None
+     * @type {number}
+     * @memberof InlineObject3
+     */
+    _double: number;
+    /**
+     * None
+     * @type {string}
+     * @memberof InlineObject3
+     */
+    string?: string;
+    /**
+     * None
+     * @type {string}
+     * @memberof InlineObject3
+     */
+    patternWithoutDelimiter: string;
+    /**
+     * None
+     * @type {string}
+     * @memberof InlineObject3
+     */
+    _byte: string;
+    /**
+     * None
+     * @type {Blob}
+     * @memberof InlineObject3
+     */
+    binary?: Blob;
+    /**
+     * None
+     * @type {Date}
+     * @memberof InlineObject3
+     */
+    date?: Date;
+    /**
+     * None
+     * @type {Date}
+     * @memberof InlineObject3
+     */
+    dateTime?: Date;
+    /**
+     * None
+     * @type {string}
+     * @memberof InlineObject3
+     */
+    password?: string;
+    /**
+     * None
+     * @type {string}
+     * @memberof InlineObject3
+     */
+    callback?: string;
+}
+
+export function InlineObject3FromJSON(json: any): InlineObject3 {
+    return InlineObject3FromJSONTyped(json, false);
+}
+
+export function InlineObject3FromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject3 {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'integer': !exists(json, 'integer') ? undefined : json['integer'],
+        'int32': !exists(json, 'int32') ? undefined : json['int32'],
+        'int64': !exists(json, 'int64') ? undefined : json['int64'],
+        'number': json['number'],
+        '_float': !exists(json, 'float') ? undefined : json['float'],
+        '_double': json['double'],
+        'string': !exists(json, 'string') ? undefined : json['string'],
+        'patternWithoutDelimiter': json['pattern_without_delimiter'],
+        '_byte': json['byte'],
+        'binary': !exists(json, 'binary') ? undefined : json['binary'],
+        'date': !exists(json, 'date') ? undefined : (new Date(json['date'])),
+        'dateTime': !exists(json, 'dateTime') ? undefined : (new Date(json['dateTime'])),
+        'password': !exists(json, 'password') ? undefined : json['password'],
+        'callback': !exists(json, 'callback') ? undefined : json['callback'],
+    };
+}
+
+export function InlineObject3ToJSON(value?: InlineObject3 | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'integer': value.integer,
+        'int32': value.int32,
+        'int64': value.int64,
+        'number': value.number,
+        'float': value._float,
+        'double': value._double,
+        'string': value.string,
+        'pattern_without_delimiter': value.patternWithoutDelimiter,
+        'byte': value._byte,
+        'binary': value.binary,
+        'date': value.date === undefined ? undefined : (value.date.toISOString().substr(0,10)),
+        'dateTime': value.dateTime === undefined ? undefined : (value.dateTime.toISOString()),
+        'password': value.password,
+        'callback': value.callback,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineObject4.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject4
+ */
+export interface InlineObject4 {
+    /**
+     * field1
+     * @type {string}
+     * @memberof InlineObject4
+     */
+    param: string;
+    /**
+     * field2
+     * @type {string}
+     * @memberof InlineObject4
+     */
+    param2: string;
+}
+
+export function InlineObject4FromJSON(json: any): InlineObject4 {
+    return InlineObject4FromJSONTyped(json, false);
+}
+
+export function InlineObject4FromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject4 {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'param': json['param'],
+        'param2': json['param2'],
+    };
+}
+
+export function InlineObject4ToJSON(value?: InlineObject4 | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'param': value.param,
+        'param2': value.param2,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineObject5.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject5
+ */
+export interface InlineObject5 {
+    /**
+     * Additional data to pass to server
+     * @type {string}
+     * @memberof InlineObject5
+     */
+    additionalMetadata?: string;
+    /**
+     * file to upload
+     * @type {Blob}
+     * @memberof InlineObject5
+     */
+    requiredFile: Blob;
+}
+
+export function InlineObject5FromJSON(json: any): InlineObject5 {
+    return InlineObject5FromJSONTyped(json, false);
+}
+
+export function InlineObject5FromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject5 {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'additionalMetadata': !exists(json, 'additionalMetadata') ? undefined : json['additionalMetadata'],
+        'requiredFile': json['requiredFile'],
+    };
+}
+
+export function InlineObject5ToJSON(value?: InlineObject5 | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'additionalMetadata': value.additionalMetadata,
+        'requiredFile': value.requiredFile,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/InlineResponseDefault.ts

@@ -0,0 +1,64 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    Foo,
+    FooFromJSON,
+    FooFromJSONTyped,
+    FooToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface InlineResponseDefault
+ */
+export interface InlineResponseDefault {
+    /**
+     * 
+     * @type {Foo}
+     * @memberof InlineResponseDefault
+     */
+    string?: Foo;
+}
+
+export function InlineResponseDefaultFromJSON(json: any): InlineResponseDefault {
+    return InlineResponseDefaultFromJSONTyped(json, false);
+}
+
+export function InlineResponseDefaultFromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineResponseDefault {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'string': !exists(json, 'string') ? undefined : FooFromJSON(json['string']),
+    };
+}
+
+export function InlineResponseDefaultToJSON(value?: InlineResponseDefault | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'string': FooToJSON(value.string),
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/List.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface List
+ */
+export interface List {
+    /**
+     * 
+     * @type {string}
+     * @memberof List
+     */
+    _123list?: string;
+}
+
+export function ListFromJSON(json: any): List {
+    return ListFromJSONTyped(json, false);
+}
+
+export function ListFromJSONTyped(json: any, ignoreDiscriminator: boolean): List {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        '_123list': !exists(json, '123-list') ? undefined : json['123-list'],
+    };
+}
+
+export function ListToJSON(value?: List | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        '123-list': value._123list,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/MapTest.ts

@@ -0,0 +1,90 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface MapTest
+ */
+export interface MapTest {
+    /**
+     * 
+     * @type {{ [key: string]: { [key: string]: string; }; }}
+     * @memberof MapTest
+     */
+    mapMapOfString?: { [key: string]: { [key: string]: string; }; };
+    /**
+     * 
+     * @type {{ [key: string]: string; }}
+     * @memberof MapTest
+     */
+    mapOfEnumString?: { [key: string]: string; };
+    /**
+     * 
+     * @type {{ [key: string]: boolean; }}
+     * @memberof MapTest
+     */
+    directMap?: { [key: string]: boolean; };
+    /**
+     * 
+     * @type {{ [key: string]: boolean; }}
+     * @memberof MapTest
+     */
+    indirectMap?: { [key: string]: boolean; };
+}
+
+export function MapTestFromJSON(json: any): MapTest {
+    return MapTestFromJSONTyped(json, false);
+}
+
+export function MapTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): MapTest {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'mapMapOfString': !exists(json, 'map_map_of_string') ? undefined : json['map_map_of_string'],
+        'mapOfEnumString': !exists(json, 'map_of_enum_string') ? undefined : json['map_of_enum_string'],
+        'directMap': !exists(json, 'direct_map') ? undefined : json['direct_map'],
+        'indirectMap': !exists(json, 'indirect_map') ? undefined : json['indirect_map'],
+    };
+}
+
+export function MapTestToJSON(value?: MapTest | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'map_map_of_string': value.mapMapOfString,
+        'map_of_enum_string': value.mapOfEnumString,
+        'direct_map': value.directMap,
+        'indirect_map': value.indirectMap,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum MapTestMapOfEnumStringEnum {
+    Upper = 'UPPER',
+    Lower = 'lower'
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/MixedPropertiesAndAdditionalPropertiesClass.ts

@@ -0,0 +1,80 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    Animal,
+    AnimalFromJSON,
+    AnimalFromJSONTyped,
+    AnimalToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface MixedPropertiesAndAdditionalPropertiesClass
+ */
+export interface MixedPropertiesAndAdditionalPropertiesClass {
+    /**
+     * 
+     * @type {string}
+     * @memberof MixedPropertiesAndAdditionalPropertiesClass
+     */
+    uuid?: string;
+    /**
+     * 
+     * @type {Date}
+     * @memberof MixedPropertiesAndAdditionalPropertiesClass
+     */
+    dateTime?: Date;
+    /**
+     * 
+     * @type {{ [key: string]: Animal; }}
+     * @memberof MixedPropertiesAndAdditionalPropertiesClass
+     */
+    map?: { [key: string]: Animal; };
+}
+
+export function MixedPropertiesAndAdditionalPropertiesClassFromJSON(json: any): MixedPropertiesAndAdditionalPropertiesClass {
+    return MixedPropertiesAndAdditionalPropertiesClassFromJSONTyped(json, false);
+}
+
+export function MixedPropertiesAndAdditionalPropertiesClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): MixedPropertiesAndAdditionalPropertiesClass {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'uuid': !exists(json, 'uuid') ? undefined : json['uuid'],
+        'dateTime': !exists(json, 'dateTime') ? undefined : (new Date(json['dateTime'])),
+        'map': !exists(json, 'map') ? undefined : (mapValues(json['map'], AnimalFromJSON)),
+    };
+}
+
+export function MixedPropertiesAndAdditionalPropertiesClassToJSON(value?: MixedPropertiesAndAdditionalPropertiesClass | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'uuid': value.uuid,
+        'dateTime': value.dateTime === undefined ? undefined : (value.dateTime.toISOString()),
+        'map': value.map === undefined ? undefined : (mapValues(value.map, AnimalToJSON)),
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Model200Response.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * Model for testing model name starting with number
+ * @export
+ * @interface Model200Response
+ */
+export interface Model200Response {
+    /**
+     * 
+     * @type {number}
+     * @memberof Model200Response
+     */
+    name?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof Model200Response
+     */
+    _class?: string;
+}
+
+export function Model200ResponseFromJSON(json: any): Model200Response {
+    return Model200ResponseFromJSONTyped(json, false);
+}
+
+export function Model200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): Model200Response {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'name': !exists(json, 'name') ? undefined : json['name'],
+        '_class': !exists(json, 'class') ? undefined : json['class'],
+    };
+}
+
+export function Model200ResponseToJSON(value?: Model200Response | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'name': value.name,
+        'class': value._class,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ModelApiResponse.ts

@@ -0,0 +1,73 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ModelApiResponse
+ */
+export interface ModelApiResponse {
+    /**
+     * 
+     * @type {number}
+     * @memberof ModelApiResponse
+     */
+    code?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof ModelApiResponse
+     */
+    type?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof ModelApiResponse
+     */
+    message?: string;
+}
+
+export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
+    return ModelApiResponseFromJSONTyped(json, false);
+}
+
+export function ModelApiResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelApiResponse {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'code': !exists(json, 'code') ? undefined : json['code'],
+        'type': !exists(json, 'type') ? undefined : json['type'],
+        'message': !exists(json, 'message') ? undefined : json['message'],
+    };
+}
+
+export function ModelApiResponseToJSON(value?: ModelApiResponse | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'code': value.code,
+        'type': value.type,
+        'message': value.message,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ModelFile.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * Must be named `File` for test.
+ * @export
+ * @interface ModelFile
+ */
+export interface ModelFile {
+    /**
+     * Test capitalization
+     * @type {string}
+     * @memberof ModelFile
+     */
+    sourceURI?: string;
+}
+
+export function ModelFileFromJSON(json: any): ModelFile {
+    return ModelFileFromJSONTyped(json, false);
+}
+
+export function ModelFileFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelFile {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'sourceURI': !exists(json, 'sourceURI') ? undefined : json['sourceURI'],
+    };
+}
+
+export function ModelFileToJSON(value?: ModelFile | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'sourceURI': value.sourceURI,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Name.ts

@@ -0,0 +1,79 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * Model for testing model name same as property name
+ * @export
+ * @interface Name
+ */
+export interface Name {
+    /**
+     * 
+     * @type {number}
+     * @memberof Name
+     */
+    name: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof Name
+     */
+    readonly snakeCase?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof Name
+     */
+    property?: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof Name
+     */
+    readonly _123number?: number;
+}
+
+export function NameFromJSON(json: any): Name {
+    return NameFromJSONTyped(json, false);
+}
+
+export function NameFromJSONTyped(json: any, ignoreDiscriminator: boolean): Name {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'name': json['name'],
+        'snakeCase': !exists(json, 'snake_case') ? undefined : json['snake_case'],
+        'property': !exists(json, 'property') ? undefined : json['property'],
+        '_123number': !exists(json, '123Number') ? undefined : json['123Number'],
+    };
+}
+
+export function NameToJSON(value?: Name | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'name': value.name,
+        'property': value.property,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/NullableClass.ts

@@ -0,0 +1,148 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface NullableClass
+ */
+export interface NullableClass {
+    [key: string]: object | any;
+    /**
+     * 
+     * @type {number}
+     * @memberof NullableClass
+     */
+    integerProp?: number | null;
+    /**
+     * 
+     * @type {number}
+     * @memberof NullableClass
+     */
+    numberProp?: number | null;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof NullableClass
+     */
+    booleanProp?: boolean | null;
+    /**
+     * 
+     * @type {string}
+     * @memberof NullableClass
+     */
+    stringProp?: string | null;
+    /**
+     * 
+     * @type {Date}
+     * @memberof NullableClass
+     */
+    dateProp?: Date | null;
+    /**
+     * 
+     * @type {Date}
+     * @memberof NullableClass
+     */
+    datetimeProp?: Date | null;
+    /**
+     * 
+     * @type {Array<object>}
+     * @memberof NullableClass
+     */
+    arrayNullableProp?: Array<object> | null;
+    /**
+     * 
+     * @type {Array<object>}
+     * @memberof NullableClass
+     */
+    arrayAndItemsNullableProp?: Array<object> | null;
+    /**
+     * 
+     * @type {Array<object>}
+     * @memberof NullableClass
+     */
+    arrayItemsNullable?: Array<object>;
+    /**
+     * 
+     * @type {{ [key: string]: object; }}
+     * @memberof NullableClass
+     */
+    objectNullableProp?: { [key: string]: object; } | null;
+    /**
+     * 
+     * @type {{ [key: string]: object; }}
+     * @memberof NullableClass
+     */
+    objectAndItemsNullableProp?: { [key: string]: object; } | null;
+    /**
+     * 
+     * @type {{ [key: string]: object; }}
+     * @memberof NullableClass
+     */
+    objectItemsNullable?: { [key: string]: object; };
+}
+
+export function NullableClassFromJSON(json: any): NullableClass {
+    return NullableClassFromJSONTyped(json, false);
+}
+
+export function NullableClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): NullableClass {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+            ...json,
+        'integerProp': !exists(json, 'integer_prop') ? undefined : json['integer_prop'],
+        'numberProp': !exists(json, 'number_prop') ? undefined : json['number_prop'],
+        'booleanProp': !exists(json, 'boolean_prop') ? undefined : json['boolean_prop'],
+        'stringProp': !exists(json, 'string_prop') ? undefined : json['string_prop'],
+        'dateProp': !exists(json, 'date_prop') ? undefined : (json['date_prop'] === null ? null : new Date(json['date_prop'])),
+        'datetimeProp': !exists(json, 'datetime_prop') ? undefined : (json['datetime_prop'] === null ? null : new Date(json['datetime_prop'])),
+        'arrayNullableProp': !exists(json, 'array_nullable_prop') ? undefined : json['array_nullable_prop'],
+        'arrayAndItemsNullableProp': !exists(json, 'array_and_items_nullable_prop') ? undefined : json['array_and_items_nullable_prop'],
+        'arrayItemsNullable': !exists(json, 'array_items_nullable') ? undefined : json['array_items_nullable'],
+        'objectNullableProp': !exists(json, 'object_nullable_prop') ? undefined : json['object_nullable_prop'],
+        'objectAndItemsNullableProp': !exists(json, 'object_and_items_nullable_prop') ? undefined : json['object_and_items_nullable_prop'],
+        'objectItemsNullable': !exists(json, 'object_items_nullable') ? undefined : json['object_items_nullable'],
+    };
+}
+
+export function NullableClassToJSON(value?: NullableClass | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+            ...value,
+        'integer_prop': value.integerProp,
+        'number_prop': value.numberProp,
+        'boolean_prop': value.booleanProp,
+        'string_prop': value.stringProp,
+        'date_prop': value.dateProp === undefined ? undefined : (value.dateProp === null ? null : value.dateProp.toISOString().substr(0,10)),
+        'datetime_prop': value.datetimeProp === undefined ? undefined : (value.datetimeProp === null ? null : value.datetimeProp.toISOString()),
+        'array_nullable_prop': value.arrayNullableProp,
+        'array_and_items_nullable_prop': value.arrayAndItemsNullableProp,
+        'array_items_nullable': value.arrayItemsNullable,
+        'object_nullable_prop': value.objectNullableProp,
+        'object_and_items_nullable_prop': value.objectAndItemsNullableProp,
+        'object_items_nullable': value.objectItemsNullable,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/NumberOnly.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface NumberOnly
+ */
+export interface NumberOnly {
+    /**
+     * 
+     * @type {number}
+     * @memberof NumberOnly
+     */
+    justNumber?: number;
+}
+
+export function NumberOnlyFromJSON(json: any): NumberOnly {
+    return NumberOnlyFromJSONTyped(json, false);
+}
+
+export function NumberOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): NumberOnly {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'justNumber': !exists(json, 'JustNumber') ? undefined : json['JustNumber'],
+    };
+}
+
+export function NumberOnlyToJSON(value?: NumberOnly | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'JustNumber': value.justNumber,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Order.ts

@@ -0,0 +1,107 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Order
+ */
+export interface Order {
+    /**
+     * 
+     * @type {number}
+     * @memberof Order
+     */
+    id?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof Order
+     */
+    petId?: number;
+    /**
+     * 
+     * @type {number}
+     * @memberof Order
+     */
+    quantity?: number;
+    /**
+     * 
+     * @type {Date}
+     * @memberof Order
+     */
+    shipDate?: Date;
+    /**
+     * Order Status
+     * @type {string}
+     * @memberof Order
+     */
+    status?: OrderStatusEnum;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof Order
+     */
+    complete?: boolean;
+}
+
+export function OrderFromJSON(json: any): Order {
+    return OrderFromJSONTyped(json, false);
+}
+
+export function OrderFromJSONTyped(json: any, ignoreDiscriminator: boolean): Order {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'id': !exists(json, 'id') ? undefined : json['id'],
+        'petId': !exists(json, 'petId') ? undefined : json['petId'],
+        'quantity': !exists(json, 'quantity') ? undefined : json['quantity'],
+        'shipDate': !exists(json, 'shipDate') ? undefined : (new Date(json['shipDate'])),
+        'status': !exists(json, 'status') ? undefined : json['status'],
+        'complete': !exists(json, 'complete') ? undefined : json['complete'],
+    };
+}
+
+export function OrderToJSON(value?: Order | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'id': value.id,
+        'petId': value.petId,
+        'quantity': value.quantity,
+        'shipDate': value.shipDate === undefined ? undefined : (value.shipDate.toISOString()),
+        'status': value.status,
+        'complete': value.complete,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum OrderStatusEnum {
+    Placed = 'placed',
+    Approved = 'approved',
+    Delivered = 'delivered'
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterComposite.ts

@@ -0,0 +1,73 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface OuterComposite
+ */
+export interface OuterComposite {
+    /**
+     * 
+     * @type {number}
+     * @memberof OuterComposite
+     */
+    myNumber?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof OuterComposite
+     */
+    myString?: string;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof OuterComposite
+     */
+    myBoolean?: boolean;
+}
+
+export function OuterCompositeFromJSON(json: any): OuterComposite {
+    return OuterCompositeFromJSONTyped(json, false);
+}
+
+export function OuterCompositeFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterComposite {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'myNumber': !exists(json, 'my_number') ? undefined : json['my_number'],
+        'myString': !exists(json, 'my_string') ? undefined : json['my_string'],
+        'myBoolean': !exists(json, 'my_boolean') ? undefined : json['my_boolean'],
+    };
+}
+
+export function OuterCompositeToJSON(value?: OuterComposite | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'my_number': value.myNumber,
+        'my_string': value.myString,
+        'my_boolean': value.myBoolean,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnum.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum OuterEnum {
+    Placed = 'placed',
+    Approved = 'approved',
+    Delivered = 'delivered'
+}
+
+export function OuterEnumFromJSON(json: any): OuterEnum {
+    return OuterEnumFromJSONTyped(json, false);
+}
+
+export function OuterEnumFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterEnum {
+    return json as OuterEnum;
+}
+
+export function OuterEnumToJSON(value?: OuterEnum | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumDefaultValue.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum OuterEnumDefaultValue {
+    Placed = 'placed',
+    Approved = 'approved',
+    Delivered = 'delivered'
+}
+
+export function OuterEnumDefaultValueFromJSON(json: any): OuterEnumDefaultValue {
+    return OuterEnumDefaultValueFromJSONTyped(json, false);
+}
+
+export function OuterEnumDefaultValueFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterEnumDefaultValue {
+    return json as OuterEnumDefaultValue;
+}
+
+export function OuterEnumDefaultValueToJSON(value?: OuterEnumDefaultValue | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumInteger.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum OuterEnumInteger {
+    NUMBER_0 = 0,
+    NUMBER_1 = 1,
+    NUMBER_2 = 2
+}
+
+export function OuterEnumIntegerFromJSON(json: any): OuterEnumInteger {
+    return OuterEnumIntegerFromJSONTyped(json, false);
+}
+
+export function OuterEnumIntegerFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterEnumInteger {
+    return json as OuterEnumInteger;
+}
+
+export function OuterEnumIntegerToJSON(value?: OuterEnumInteger | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumIntegerDefaultValue.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum OuterEnumIntegerDefaultValue {
+    NUMBER_0 = 0,
+    NUMBER_1 = 1,
+    NUMBER_2 = 2
+}
+
+export function OuterEnumIntegerDefaultValueFromJSON(json: any): OuterEnumIntegerDefaultValue {
+    return OuterEnumIntegerDefaultValueFromJSONTyped(json, false);
+}
+
+export function OuterEnumIntegerDefaultValueFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterEnumIntegerDefaultValue {
+    return json as OuterEnumIntegerDefaultValue;
+}
+
+export function OuterEnumIntegerDefaultValueToJSON(value?: OuterEnumIntegerDefaultValue | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Pet.ts

@@ -0,0 +1,118 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    Category,
+    CategoryFromJSON,
+    CategoryFromJSONTyped,
+    CategoryToJSON,
+    Tag,
+    TagFromJSON,
+    TagFromJSONTyped,
+    TagToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface Pet
+ */
+export interface Pet {
+    /**
+     * 
+     * @type {number}
+     * @memberof Pet
+     */
+    id?: number;
+    /**
+     * 
+     * @type {Category}
+     * @memberof Pet
+     */
+    category?: Category;
+    /**
+     * 
+     * @type {string}
+     * @memberof Pet
+     */
+    name: string;
+    /**
+     * 
+     * @type {Array<string>}
+     * @memberof Pet
+     */
+    photoUrls: Array<string>;
+    /**
+     * 
+     * @type {Array<Tag>}
+     * @memberof Pet
+     */
+    tags?: Array<Tag>;
+    /**
+     * pet status in the store
+     * @type {string}
+     * @memberof Pet
+     */
+    status?: PetStatusEnum;
+}
+
+export function PetFromJSON(json: any): Pet {
+    return PetFromJSONTyped(json, false);
+}
+
+export function PetFromJSONTyped(json: any, ignoreDiscriminator: boolean): Pet {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'id': !exists(json, 'id') ? undefined : json['id'],
+        'category': !exists(json, 'category') ? undefined : CategoryFromJSON(json['category']),
+        'name': json['name'],
+        'photoUrls': json['photoUrls'],
+        'tags': !exists(json, 'tags') ? undefined : ((json['tags'] as Array<any>).map(TagFromJSON)),
+        'status': !exists(json, 'status') ? undefined : json['status'],
+    };
+}
+
+export function PetToJSON(value?: Pet | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'id': value.id,
+        'category': CategoryToJSON(value.category),
+        'name': value.name,
+        'photoUrls': value.photoUrls,
+        'tags': value.tags === undefined ? undefined : ((value.tags as Array<any>).map(TagToJSON)),
+        'status': value.status,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum PetStatusEnum {
+    Available = 'available',
+    Pending = 'pending',
+    Sold = 'sold'
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/ReadOnlyFirst.ts

@@ -0,0 +1,64 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface ReadOnlyFirst
+ */
+export interface ReadOnlyFirst {
+    /**
+     * 
+     * @type {string}
+     * @memberof ReadOnlyFirst
+     */
+    readonly bar?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof ReadOnlyFirst
+     */
+    baz?: string;
+}
+
+export function ReadOnlyFirstFromJSON(json: any): ReadOnlyFirst {
+    return ReadOnlyFirstFromJSONTyped(json, false);
+}
+
+export function ReadOnlyFirstFromJSONTyped(json: any, ignoreDiscriminator: boolean): ReadOnlyFirst {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'bar': !exists(json, 'bar') ? undefined : json['bar'],
+        'baz': !exists(json, 'baz') ? undefined : json['baz'],
+    };
+}
+
+export function ReadOnlyFirstToJSON(value?: ReadOnlyFirst | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'baz': value.baz,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Return.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * Model for testing reserved words
+ * @export
+ * @interface Return
+ */
+export interface Return {
+    /**
+     * 
+     * @type {number}
+     * @memberof Return
+     */
+    _return?: number;
+}
+
+export function ReturnFromJSON(json: any): Return {
+    return ReturnFromJSONTyped(json, false);
+}
+
+export function ReturnFromJSONTyped(json: any, ignoreDiscriminator: boolean): Return {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        '_return': !exists(json, 'return') ? undefined : json['return'],
+    };
+}
+
+export function ReturnToJSON(value?: Return | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'return': value._return,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/SpecialModelName.ts

@@ -0,0 +1,57 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface SpecialModelName
+ */
+export interface SpecialModelName {
+    /**
+     * 
+     * @type {number}
+     * @memberof SpecialModelName
+     */
+    $specialPropertyName?: number;
+}
+
+export function SpecialModelNameFromJSON(json: any): SpecialModelName {
+    return SpecialModelNameFromJSONTyped(json, false);
+}
+
+export function SpecialModelNameFromJSONTyped(json: any, ignoreDiscriminator: boolean): SpecialModelName {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        '$specialPropertyName': !exists(json, '$special[property.name]') ? undefined : json['$special[property.name]'],
+    };
+}
+
+export function SpecialModelNameToJSON(value?: SpecialModelName | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        '$special[property.name]': value.$specialPropertyName,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/Tag.ts

@@ -0,0 +1,65 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface Tag
+ */
+export interface Tag {
+    /**
+     * 
+     * @type {number}
+     * @memberof Tag
+     */
+    id?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof Tag
+     */
+    name?: string;
+}
+
+export function TagFromJSON(json: any): Tag {
+    return TagFromJSONTyped(json, false);
+}
+
+export function TagFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tag {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'id': !exists(json, 'id') ? undefined : json['id'],
+        'name': !exists(json, 'name') ? undefined : json['name'],
+    };
+}
+
+export function TagToJSON(value?: Tag | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'id': value.id,
+        'name': value.name,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/User.ts

@@ -0,0 +1,113 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface User
+ */
+export interface User {
+    /**
+     * 
+     * @type {number}
+     * @memberof User
+     */
+    id?: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof User
+     */
+    username?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof User
+     */
+    firstName?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof User
+     */
+    lastName?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof User
+     */
+    email?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof User
+     */
+    password?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof User
+     */
+    phone?: string;
+    /**
+     * User Status
+     * @type {number}
+     * @memberof User
+     */
+    userStatus?: number;
+}
+
+export function UserFromJSON(json: any): User {
+    return UserFromJSONTyped(json, false);
+}
+
+export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'id': !exists(json, 'id') ? undefined : json['id'],
+        'username': !exists(json, 'username') ? undefined : json['username'],
+        'firstName': !exists(json, 'firstName') ? undefined : json['firstName'],
+        'lastName': !exists(json, 'lastName') ? undefined : json['lastName'],
+        'email': !exists(json, 'email') ? undefined : json['email'],
+        'password': !exists(json, 'password') ? undefined : json['password'],
+        'phone': !exists(json, 'phone') ? undefined : json['phone'],
+        'userStatus': !exists(json, 'userStatus') ? undefined : json['userStatus'],
+    };
+}
+
+export function UserToJSON(value?: User | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'id': value.id,
+        'username': value.username,
+        'firstName': value.firstName,
+        'lastName': value.lastName,
+        'email': value.email,
+        'password': value.password,
+        'phone': value.phone,
+        'userStatus': value.userStatus,
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/index.ts

@@ -0,0 +1,49 @@
+export * from './AdditionalPropertiesClass';
+export * from './Animal';
+export * from './ArrayOfArrayOfNumberOnly';
+export * from './ArrayOfNumberOnly';
+export * from './ArrayTest';
+export * from './Capitalization';
+export * from './Cat';
+export * from './CatAllOf';
+export * from './Category';
+export * from './ClassModel';
+export * from './Client';
+export * from './Dog';
+export * from './DogAllOf';
+export * from './EnumArrays';
+export * from './EnumClass';
+export * from './EnumTest';
+export * from './FileSchemaTestClass';
+export * from './Foo';
+export * from './FormatTest';
+export * from './HasOnlyReadOnly';
+export * from './HealthCheckResult';
+export * from './InlineObject';
+export * from './InlineObject1';
+export * from './InlineObject2';
+export * from './InlineObject3';
+export * from './InlineObject4';
+export * from './InlineObject5';
+export * from './InlineResponseDefault';
+export * from './List';
+export * from './MapTest';
+export * from './MixedPropertiesAndAdditionalPropertiesClass';
+export * from './Model200Response';
+export * from './ModelApiResponse';
+export * from './ModelFile';
+export * from './Name';
+export * from './NullableClass';
+export * from './NumberOnly';
+export * from './Order';
+export * from './OuterComposite';
+export * from './OuterEnum';
+export * from './OuterEnumDefaultValue';
+export * from './OuterEnumInteger';
+export * from './OuterEnumIntegerDefaultValue';
+export * from './Pet';
+export * from './ReadOnlyFirst';
+export * from './Return';
+export * from './SpecialModelName';
+export * from './Tag';
+export * from './User';

samples/client/petstore/typescript-fetch/builds/default-v3.0/runtime.ts

@@ -0,0 +1,316 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenAPI Petstore
+ * This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export const BASE_PATH = "http://petstore.swagger.io:80/v2".replace(/\/+$/, "");
+
+const isBlob = (value: any) => typeof Blob !== 'undefined' && value instanceof Blob;
+
+/**
+ * This is the base class for all generated API classes.
+ */
+export class BaseAPI {
+
+    private middleware: Middleware[];
+
+    constructor(protected configuration = new Configuration()) {
+        this.middleware = configuration.middleware;
+    }
+
+    withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
+        const next = this.clone<T>();
+        next.middleware = next.middleware.concat(...middlewares);
+        return next;
+    }
+
+    withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware['pre']>) {
+        const middlewares = preMiddlewares.map((pre) => ({ pre }));
+        return this.withMiddleware<T>(...middlewares);
+    }
+
+    withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
+        const middlewares = postMiddlewares.map((post) => ({ post }));
+        return this.withMiddleware<T>(...middlewares);
+    }
+
+    protected async request(context: RequestOpts): Promise<Response> {
+        const { url, init } = this.createFetchParams(context);
+        const response = await this.fetchApi(url, init);
+        if (response.status >= 200 && response.status < 300) {
+            return response;
+        }
+        throw response;
+    }
+
+    private createFetchParams(context: RequestOpts) {
+        let url = this.configuration.basePath + context.path;
+        if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+            // only add the querystring to the URL if there are query parameters.
+            // this is done to avoid urls ending with a "?" character which buggy webservers
+            // do not handle correctly sometimes.
+            url += '?' + this.configuration.queryParamsStringify(context.query);
+        }
+        const body = ((typeof FormData !== "undefined" && context.body instanceof FormData) || context.body instanceof URLSearchParams || isBlob(context.body))
+	    ? context.body
+	    : JSON.stringify(context.body);
+
+        const headers = Object.assign({}, this.configuration.headers, context.headers);
+        const init = {
+            method: context.method,
+            headers: headers,
+            body,
+            credentials: this.configuration.credentials
+        };
+        return { url, init };
+    }
+
+    private fetchApi = async (url: string, init: RequestInit) => {
+        let fetchParams = { url, init };
+        for (const middleware of this.middleware) {
+            if (middleware.pre) {
+                fetchParams = await middleware.pre({
+                    fetch: this.fetchApi,
+                    ...fetchParams,
+                }) || fetchParams;
+            }
+        }
+        let response = await this.configuration.fetchApi(fetchParams.url, fetchParams.init);
+        for (const middleware of this.middleware) {
+            if (middleware.post) {
+                response = await middleware.post({
+                    fetch: this.fetchApi,
+                    url,
+                    init,
+                    response: response.clone(),
+                }) || response;
+            }
+        }
+        return response;
+    }
+
+    /**
+     * Create a shallow clone of `this` by constructing a new instance
+     * and then shallow cloning data members.
+     */
+    private clone<T extends BaseAPI>(this: T): T {
+        const constructor = this.constructor as any;
+        const next = new constructor(this.configuration);
+        next.middleware = this.middleware.slice();
+        return next;
+    }
+};
+
+export class RequiredError extends Error {
+    name: "RequiredError" = "RequiredError";
+    constructor(public field: string, msg?: string) {
+        super(msg);
+    }
+}
+
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+export type FetchAPI = GlobalFetch['fetch'];
+
+export interface ConfigurationParameters {
+    basePath?: string; // override base path
+    fetchApi?: FetchAPI; // override for fetch implementation
+    middleware?: Middleware[]; // middleware to apply before/after fetch requests
+    queryParamsStringify?: (params: HTTPQuery) => string; // stringify function for query strings
+    username?: string; // parameter for basic security
+    password?: string; // parameter for basic security
+    apiKey?: string | ((name: string) => string); // parameter for apiKey security
+    accessToken?: string | ((name?: string, scopes?: string[]) => string); // parameter for oauth2 security
+    headers?: HTTPHeaders; //header params we want to use on every request
+    credentials?: RequestCredentials; //value for the credentials param we want to use on each request
+}
+
+export class Configuration {
+    constructor(private configuration: ConfigurationParameters = {}) {}
+
+    get basePath(): string {
+        return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+    }
+
+    get fetchApi(): FetchAPI {
+        return this.configuration.fetchApi || window.fetch.bind(window);
+    }
+
+    get middleware(): Middleware[] {
+        return this.configuration.middleware || [];
+    }
+
+    get queryParamsStringify(): (params: HTTPQuery) => string {
+        return this.configuration.queryParamsStringify || querystring;
+    }
+
+    get username(): string | undefined {
+        return this.configuration.username;
+    }
+
+    get password(): string | undefined {
+        return this.configuration.password;
+    }
+
+    get apiKey(): ((name: string) => string) | undefined {
+        const apiKey = this.configuration.apiKey;
+        if (apiKey) {
+            return typeof apiKey === 'function' ? apiKey : () => apiKey;
+        }
+        return undefined;
+    }
+
+    get accessToken(): ((name: string, scopes?: string[]) => string) | undefined {
+        const accessToken = this.configuration.accessToken;
+        if (accessToken) {
+            return typeof accessToken === 'function' ? accessToken : () => accessToken;
+        }
+        return undefined;
+    }
+
+    get headers():  HTTPHeaders | undefined {
+        return this.configuration.headers;
+    }
+
+    get credentials(): RequestCredentials | undefined {
+        return this.configuration.credentials;
+    }
+}
+
+export type Json = any;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type HTTPHeaders = { [key: string]: string };
+export type HTTPQuery = { [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | HTTPQuery };
+export type HTTPBody = Json | FormData | URLSearchParams;
+export type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
+
+export interface FetchParams {
+    url: string;
+    init: RequestInit;
+}
+
+export interface RequestOpts {
+    path: string;
+    method: HTTPMethod;
+    headers: HTTPHeaders;
+    query?: HTTPQuery;
+    body?: HTTPBody;
+}
+
+export function exists(json: any, key: string) {
+    const value = json[key];
+    return value !== null && value !== undefined;
+}
+
+export function querystring(params: HTTPQuery, prefix: string = ''): string {
+    return Object.keys(params)
+        .map((key) => {
+            const fullKey = prefix + (prefix.length ? `[${key}]` : key);
+            const value = params[key];
+            if (value instanceof Array) {
+                const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
+                    .join(`&${encodeURIComponent(fullKey)}=`);
+                return `${encodeURIComponent(fullKey)}=${multiValue}`;
+            }
+            if (value instanceof Object) {
+                return querystring(value as HTTPQuery, fullKey);
+            }
+            return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+        })
+        .filter(part => part.length > 0)
+        .join('&');
+}
+
+export function mapValues(data: any, fn: (item: any) => any) {
+  return Object.keys(data).reduce(
+    (acc, key) => ({ ...acc, [key]: fn(data[key]) }),
+    {}
+  );
+}
+
+export function canConsumeForm(consumes: Consume[]): boolean {
+    for (const consume of consumes) {
+        if ('multipart/form-data' === consume.contentType) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export interface Consume {
+    contentType: string
+}
+
+export interface RequestContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+}
+
+export interface ResponseContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    response: Response;
+}
+
+export interface Middleware {
+    pre?(context: RequestContext): Promise<FetchParams | void>;
+    post?(context: ResponseContext): Promise<Response | void>;
+}
+
+export interface ApiResponse<T> {
+    raw: Response;
+    value(): Promise<T>;
+}
+
+export interface ResponseTransformer<T> {
+    (json: any): T;
+}
+
+export class JSONApiResponse<T> {
+    constructor(public raw: Response, private transformer: ResponseTransformer<T> = (jsonValue: any) => jsonValue) {}
+
+    async value(): Promise<T> {
+        return this.transformer(await this.raw.json());
+    }
+}
+
+export class VoidApiResponse {
+    constructor(public raw: Response) {}
+
+    async value(): Promise<void> {
+        return undefined;
+    }
+}
+
+export class BlobApiResponse {
+    constructor(public raw: Response) {}
+
+    async value(): Promise<Blob> {
+        return await this.raw.blob();
+    };
+}
+
+export class TextApiResponse {
+    constructor(public raw: Response) {}
+
+    async value(): Promise<string> {
+        return await this.raw.text();
+    };
+}

samples/client/petstore/typescript-fetch/builds/enum/.openapi-generator-ignore

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

samples/client/petstore/typescript-fetch/builds/enum/.openapi-generator/FILES

@@ -0,0 +1,10 @@
+apis/DefaultApi.ts
+apis/index.ts
+index.ts
+models/EnumPatternObject.ts
+models/InlineObject.ts
+models/InlineResponse200.ts
+models/NumberEnum.ts
+models/StringEnum.ts
+models/index.ts
+runtime.ts

samples/client/petstore/typescript-fetch/builds/enum/.openapi-generator/VERSION

@@ -0,0 +1 @@
+5.0.0-SNAPSHOT

samples/client/petstore/typescript-fetch/builds/enum/apis/DefaultApi.ts

@@ -0,0 +1,215 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+import * as runtime from '../runtime';
+import {
+    EnumPatternObject,
+    EnumPatternObjectFromJSON,
+    EnumPatternObjectToJSON,
+    InlineObject,
+    InlineObjectFromJSON,
+    InlineObjectToJSON,
+    InlineResponse200,
+    InlineResponse200FromJSON,
+    InlineResponse200ToJSON,
+    NumberEnum,
+    NumberEnumFromJSON,
+    NumberEnumToJSON,
+    StringEnum,
+    StringEnumFromJSON,
+    StringEnumToJSON,
+} from '../models';
+
+export interface FakeEnumRequestGetInlineRequest {
+    stringEnum?: FakeEnumRequestGetInlineStringEnumEnum;
+    nullableStringEnum?: string | null;
+    numberEnum?: FakeEnumRequestGetInlineNumberEnumEnum;
+    nullableNumberEnum?: number | null;
+}
+
+export interface FakeEnumRequestGetRefRequest {
+    stringEnum?: StringEnum;
+    nullableStringEnum?: StringEnum | null;
+    numberEnum?: NumberEnum;
+    nullableNumberEnum?: NumberEnum | null;
+}
+
+export interface FakeEnumRequestPostInlineRequest {
+    inlineObject?: InlineObject;
+}
+
+export interface FakeEnumRequestPostRefRequest {
+    enumPatternObject?: EnumPatternObject;
+}
+
+/**
+ * 
+ */
+export class DefaultApi extends runtime.BaseAPI {
+
+    /**
+     */
+    async fakeEnumRequestGetInlineRaw(requestParameters: FakeEnumRequestGetInlineRequest): Promise<runtime.ApiResponse<InlineResponse200>> {
+        const queryParameters: any = {};
+
+        if (requestParameters.stringEnum !== undefined) {
+            queryParameters['string-enum'] = requestParameters.stringEnum;
+        }
+
+        if (requestParameters.nullableStringEnum !== undefined) {
+            queryParameters['nullable-string-enum'] = requestParameters.nullableStringEnum;
+        }
+
+        if (requestParameters.numberEnum !== undefined) {
+            queryParameters['number-enum'] = requestParameters.numberEnum;
+        }
+
+        if (requestParameters.nullableNumberEnum !== undefined) {
+            queryParameters['nullable-number-enum'] = requestParameters.nullableNumberEnum;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/fake/enum-request-inline`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => InlineResponse200FromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async fakeEnumRequestGetInline(requestParameters: FakeEnumRequestGetInlineRequest): Promise<InlineResponse200> {
+        const response = await this.fakeEnumRequestGetInlineRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async fakeEnumRequestGetRefRaw(requestParameters: FakeEnumRequestGetRefRequest): Promise<runtime.ApiResponse<EnumPatternObject>> {
+        const queryParameters: any = {};
+
+        if (requestParameters.stringEnum !== undefined) {
+            queryParameters['string-enum'] = requestParameters.stringEnum;
+        }
+
+        if (requestParameters.nullableStringEnum !== undefined) {
+            queryParameters['nullable-string-enum'] = requestParameters.nullableStringEnum;
+        }
+
+        if (requestParameters.numberEnum !== undefined) {
+            queryParameters['number-enum'] = requestParameters.numberEnum;
+        }
+
+        if (requestParameters.nullableNumberEnum !== undefined) {
+            queryParameters['nullable-number-enum'] = requestParameters.nullableNumberEnum;
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/fake/enum-request-ref`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EnumPatternObjectFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async fakeEnumRequestGetRef(requestParameters: FakeEnumRequestGetRefRequest): Promise<EnumPatternObject> {
+        const response = await this.fakeEnumRequestGetRefRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async fakeEnumRequestPostInlineRaw(requestParameters: FakeEnumRequestPostInlineRequest): Promise<runtime.ApiResponse<InlineObject>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/enum-request-inline`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: InlineObjectToJSON(requestParameters.inlineObject),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => InlineObjectFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async fakeEnumRequestPostInline(requestParameters: FakeEnumRequestPostInlineRequest): Promise<InlineObject> {
+        const response = await this.fakeEnumRequestPostInlineRaw(requestParameters);
+        return await response.value();
+    }
+
+    /**
+     */
+    async fakeEnumRequestPostRefRaw(requestParameters: FakeEnumRequestPostRefRequest): Promise<runtime.ApiResponse<EnumPatternObject>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        const response = await this.request({
+            path: `/fake/enum-request-ref`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: EnumPatternObjectToJSON(requestParameters.enumPatternObject),
+        });
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EnumPatternObjectFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async fakeEnumRequestPostRef(requestParameters: FakeEnumRequestPostRefRequest): Promise<EnumPatternObject> {
+        const response = await this.fakeEnumRequestPostRefRaw(requestParameters);
+        return await response.value();
+    }
+
+}
+
+/**
+    * @export
+    * @enum {string}
+    */
+export enum FakeEnumRequestGetInlineStringEnumEnum {
+    One = 'one',
+    Two = 'two',
+    Three = 'three'
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export enum FakeEnumRequestGetInlineNumberEnumEnum {
+    NUMBER_1 = 1,
+    NUMBER_2 = 2,
+    NUMBER_3 = 3
+}

samples/client/petstore/typescript-fetch/builds/enum/apis/index.ts

@@ -0,0 +1 @@
+export * from './DefaultApi';

samples/client/petstore/typescript-fetch/builds/enum/index.ts

@@ -0,0 +1,3 @@
+export * from './runtime';
+export * from './apis';
+export * from './models';

samples/client/petstore/typescript-fetch/builds/enum/models/EnumPatternObject.ts

@@ -0,0 +1,92 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import {
+    NumberEnum,
+    NumberEnumFromJSON,
+    NumberEnumFromJSONTyped,
+    NumberEnumToJSON,
+    StringEnum,
+    StringEnumFromJSON,
+    StringEnumFromJSONTyped,
+    StringEnumToJSON,
+} from './';
+
+/**
+ * 
+ * @export
+ * @interface EnumPatternObject
+ */
+export interface EnumPatternObject {
+    /**
+     * 
+     * @type {StringEnum}
+     * @memberof EnumPatternObject
+     */
+    stringEnum?: StringEnum;
+    /**
+     * 
+     * @type {StringEnum}
+     * @memberof EnumPatternObject
+     */
+    nullableStringEnum?: StringEnum | null;
+    /**
+     * 
+     * @type {NumberEnum}
+     * @memberof EnumPatternObject
+     */
+    numberEnum?: NumberEnum;
+    /**
+     * 
+     * @type {NumberEnum}
+     * @memberof EnumPatternObject
+     */
+    nullableNumberEnum?: NumberEnum | null;
+}
+
+export function EnumPatternObjectFromJSON(json: any): EnumPatternObject {
+    return EnumPatternObjectFromJSONTyped(json, false);
+}
+
+export function EnumPatternObjectFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumPatternObject {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'stringEnum': !exists(json, 'string-enum') ? undefined : StringEnumFromJSON(json['string-enum']),
+        'nullableStringEnum': !exists(json, 'nullable-string-enum') ? undefined : StringEnumFromJSON(json['nullable-string-enum']),
+        'numberEnum': !exists(json, 'number-enum') ? undefined : NumberEnumFromJSON(json['number-enum']),
+        'nullableNumberEnum': !exists(json, 'nullable-number-enum') ? undefined : NumberEnumFromJSON(json['nullable-number-enum']),
+    };
+}
+
+export function EnumPatternObjectToJSON(value?: EnumPatternObject | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'string-enum': StringEnumToJSON(value.stringEnum),
+        'nullable-string-enum': StringEnumToJSON(value.nullableStringEnum),
+        'number-enum': NumberEnumToJSON(value.numberEnum),
+        'nullable-number-enum': NumberEnumToJSON(value.nullableNumberEnum),
+    };
+}
+
+

samples/client/petstore/typescript-fetch/builds/enum/models/InlineObject.ts

@@ -0,0 +1,100 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineObject
+ */
+export interface InlineObject {
+    /**
+     * 
+     * @type {string}
+     * @memberof InlineObject
+     */
+    stringEnum?: InlineObjectStringEnumEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof InlineObject
+     */
+    nullableStringEnum?: string | null;
+    /**
+     * 
+     * @type {number}
+     * @memberof InlineObject
+     */
+    numberEnum?: InlineObjectNumberEnumEnum;
+    /**
+     * 
+     * @type {number}
+     * @memberof InlineObject
+     */
+    nullableNumberEnum?: number | null;
+}
+
+export function InlineObjectFromJSON(json: any): InlineObject {
+    return InlineObjectFromJSONTyped(json, false);
+}
+
+export function InlineObjectFromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineObject {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'stringEnum': !exists(json, 'string-enum') ? undefined : json['string-enum'],
+        'nullableStringEnum': !exists(json, 'nullable-string-enum') ? undefined : json['nullable-string-enum'],
+        'numberEnum': !exists(json, 'number-enum') ? undefined : json['number-enum'],
+        'nullableNumberEnum': !exists(json, 'nullable-number-enum') ? undefined : json['nullable-number-enum'],
+    };
+}
+
+export function InlineObjectToJSON(value?: InlineObject | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'string-enum': value.stringEnum,
+        'nullable-string-enum': value.nullableStringEnum,
+        'number-enum': value.numberEnum,
+        'nullable-number-enum': value.nullableNumberEnum,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum InlineObjectStringEnumEnum {
+    One = 'one',
+    Two = 'two',
+    Three = 'three'
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum InlineObjectNumberEnumEnum {
+    NUMBER_1 = 1,
+    NUMBER_2 = 2,
+    NUMBER_3 = 3
+}
+
+

samples/client/petstore/typescript-fetch/builds/enum/models/InlineResponse200.ts

@@ -0,0 +1,100 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface InlineResponse200
+ */
+export interface InlineResponse200 {
+    /**
+     * 
+     * @type {string}
+     * @memberof InlineResponse200
+     */
+    stringEnum?: InlineResponse200StringEnumEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof InlineResponse200
+     */
+    nullableStringEnum?: string | null;
+    /**
+     * 
+     * @type {number}
+     * @memberof InlineResponse200
+     */
+    numberEnum?: InlineResponse200NumberEnumEnum;
+    /**
+     * 
+     * @type {number}
+     * @memberof InlineResponse200
+     */
+    nullableNumberEnum?: number | null;
+}
+
+export function InlineResponse200FromJSON(json: any): InlineResponse200 {
+    return InlineResponse200FromJSONTyped(json, false);
+}
+
+export function InlineResponse200FromJSONTyped(json: any, ignoreDiscriminator: boolean): InlineResponse200 {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'stringEnum': !exists(json, 'string-enum') ? undefined : json['string-enum'],
+        'nullableStringEnum': !exists(json, 'nullable-string-enum') ? undefined : json['nullable-string-enum'],
+        'numberEnum': !exists(json, 'number-enum') ? undefined : json['number-enum'],
+        'nullableNumberEnum': !exists(json, 'nullable-number-enum') ? undefined : json['nullable-number-enum'],
+    };
+}
+
+export function InlineResponse200ToJSON(value?: InlineResponse200 | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'string-enum': value.stringEnum,
+        'nullable-string-enum': value.nullableStringEnum,
+        'number-enum': value.numberEnum,
+        'nullable-number-enum': value.nullableNumberEnum,
+    };
+}
+
+/**
+* @export
+* @enum {string}
+*/
+export enum InlineResponse200StringEnumEnum {
+    One = 'one',
+    Two = 'two',
+    Three = 'three'
+}
+/**
+* @export
+* @enum {string}
+*/
+export enum InlineResponse200NumberEnumEnum {
+    NUMBER_1 = 1,
+    NUMBER_2 = 2,
+    NUMBER_3 = 3
+}
+
+

samples/client/petstore/typescript-fetch/builds/enum/models/NumberEnum.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum NumberEnum {
+    NUMBER_1 = 1,
+    NUMBER_2 = 2,
+    NUMBER_3 = 3
+}
+
+export function NumberEnumFromJSON(json: any): NumberEnum {
+    return NumberEnumFromJSONTyped(json, false);
+}
+
+export function NumberEnumFromJSONTyped(json: any, ignoreDiscriminator: boolean): NumberEnum {
+    return json as NumberEnum;
+}
+
+export function NumberEnumToJSON(value?: NumberEnum | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/enum/models/StringEnum.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * 
+ * @export
+ * @enum {string}
+ */
+export enum StringEnum {
+    One = 'one',
+    Two = 'two',
+    Three = 'three'
+}
+
+export function StringEnumFromJSON(json: any): StringEnum {
+    return StringEnumFromJSONTyped(json, false);
+}
+
+export function StringEnumFromJSONTyped(json: any, ignoreDiscriminator: boolean): StringEnum {
+    return json as StringEnum;
+}
+
+export function StringEnumToJSON(value?: StringEnum | null): any {
+    return value as any;
+}
+

samples/client/petstore/typescript-fetch/builds/enum/models/index.ts

@@ -0,0 +1,5 @@
+export * from './EnumPatternObject';
+export * from './InlineObject';
+export * from './InlineResponse200';
+export * from './NumberEnum';
+export * from './StringEnum';

samples/client/petstore/typescript-fetch/builds/enum/runtime.ts

@@ -0,0 +1,316 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Enum test
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+export const BASE_PATH = "http://localhost:3000".replace(/\/+$/, "");
+
+const isBlob = (value: any) => typeof Blob !== 'undefined' && value instanceof Blob;
+
+/**
+ * This is the base class for all generated API classes.
+ */
+export class BaseAPI {
+
+    private middleware: Middleware[];
+
+    constructor(protected configuration = new Configuration()) {
+        this.middleware = configuration.middleware;
+    }
+
+    withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]) {
+        const next = this.clone<T>();
+        next.middleware = next.middleware.concat(...middlewares);
+        return next;
+    }
+
+    withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware['pre']>) {
+        const middlewares = preMiddlewares.map((pre) => ({ pre }));
+        return this.withMiddleware<T>(...middlewares);
+    }
+
+    withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware['post']>) {
+        const middlewares = postMiddlewares.map((post) => ({ post }));
+        return this.withMiddleware<T>(...middlewares);
+    }
+
+    protected async request(context: RequestOpts): Promise<Response> {
+        const { url, init } = this.createFetchParams(context);
+        const response = await this.fetchApi(url, init);
+        if (response.status >= 200 && response.status < 300) {
+            return response;
+        }
+        throw response;
+    }
+
+    private createFetchParams(context: RequestOpts) {
+        let url = this.configuration.basePath + context.path;
+        if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+            // only add the querystring to the URL if there are query parameters.
+            // this is done to avoid urls ending with a "?" character which buggy webservers
+            // do not handle correctly sometimes.
+            url += '?' + this.configuration.queryParamsStringify(context.query);
+        }
+        const body = ((typeof FormData !== "undefined" && context.body instanceof FormData) || context.body instanceof URLSearchParams || isBlob(context.body))
+	    ? context.body
+	    : JSON.stringify(context.body);
+
+        const headers = Object.assign({}, this.configuration.headers, context.headers);
+        const init = {
+            method: context.method,
+            headers: headers,
+            body,
+            credentials: this.configuration.credentials
+        };
+        return { url, init };
+    }
+
+    private fetchApi = async (url: string, init: RequestInit) => {
+        let fetchParams = { url, init };
+        for (const middleware of this.middleware) {
+            if (middleware.pre) {
+                fetchParams = await middleware.pre({
+                    fetch: this.fetchApi,
+                    ...fetchParams,
+                }) || fetchParams;
+            }
+        }
+        let response = await this.configuration.fetchApi(fetchParams.url, fetchParams.init);
+        for (const middleware of this.middleware) {
+            if (middleware.post) {
+                response = await middleware.post({
+                    fetch: this.fetchApi,
+                    url,
+                    init,
+                    response: response.clone(),
+                }) || response;
+            }
+        }
+        return response;
+    }
+
+    /**
+     * Create a shallow clone of `this` by constructing a new instance
+     * and then shallow cloning data members.
+     */
+    private clone<T extends BaseAPI>(this: T): T {
+        const constructor = this.constructor as any;
+        const next = new constructor(this.configuration);
+        next.middleware = this.middleware.slice();
+        return next;
+    }
+};
+
+export class RequiredError extends Error {
+    name: "RequiredError" = "RequiredError";
+    constructor(public field: string, msg?: string) {
+        super(msg);
+    }
+}
+
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+export type FetchAPI = GlobalFetch['fetch'];
+
+export interface ConfigurationParameters {
+    basePath?: string; // override base path
+    fetchApi?: FetchAPI; // override for fetch implementation
+    middleware?: Middleware[]; // middleware to apply before/after fetch requests
+    queryParamsStringify?: (params: HTTPQuery) => string; // stringify function for query strings
+    username?: string; // parameter for basic security
+    password?: string; // parameter for basic security
+    apiKey?: string | ((name: string) => string); // parameter for apiKey security
+    accessToken?: string | ((name?: string, scopes?: string[]) => string); // parameter for oauth2 security
+    headers?: HTTPHeaders; //header params we want to use on every request
+    credentials?: RequestCredentials; //value for the credentials param we want to use on each request
+}
+
+export class Configuration {
+    constructor(private configuration: ConfigurationParameters = {}) {}
+
+    get basePath(): string {
+        return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+    }
+
+    get fetchApi(): FetchAPI {
+        return this.configuration.fetchApi || window.fetch.bind(window);
+    }
+
+    get middleware(): Middleware[] {
+        return this.configuration.middleware || [];
+    }
+
+    get queryParamsStringify(): (params: HTTPQuery) => string {
+        return this.configuration.queryParamsStringify || querystring;
+    }
+
+    get username(): string | undefined {
+        return this.configuration.username;
+    }
+
+    get password(): string | undefined {
+        return this.configuration.password;
+    }
+
+    get apiKey(): ((name: string) => string) | undefined {
+        const apiKey = this.configuration.apiKey;
+        if (apiKey) {
+            return typeof apiKey === 'function' ? apiKey : () => apiKey;
+        }
+        return undefined;
+    }
+
+    get accessToken(): ((name: string, scopes?: string[]) => string) | undefined {
+        const accessToken = this.configuration.accessToken;
+        if (accessToken) {
+            return typeof accessToken === 'function' ? accessToken : () => accessToken;
+        }
+        return undefined;
+    }
+
+    get headers():  HTTPHeaders | undefined {
+        return this.configuration.headers;
+    }
+
+    get credentials(): RequestCredentials | undefined {
+        return this.configuration.credentials;
+    }
+}
+
+export type Json = any;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type HTTPHeaders = { [key: string]: string };
+export type HTTPQuery = { [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | HTTPQuery };
+export type HTTPBody = Json | FormData | URLSearchParams;
+export type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
+
+export interface FetchParams {
+    url: string;
+    init: RequestInit;
+}
+
+export interface RequestOpts {
+    path: string;
+    method: HTTPMethod;
+    headers: HTTPHeaders;
+    query?: HTTPQuery;
+    body?: HTTPBody;
+}
+
+export function exists(json: any, key: string) {
+    const value = json[key];
+    return value !== null && value !== undefined;
+}
+
+export function querystring(params: HTTPQuery, prefix: string = ''): string {
+    return Object.keys(params)
+        .map((key) => {
+            const fullKey = prefix + (prefix.length ? `[${key}]` : key);
+            const value = params[key];
+            if (value instanceof Array) {
+                const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
+                    .join(`&${encodeURIComponent(fullKey)}=`);
+                return `${encodeURIComponent(fullKey)}=${multiValue}`;
+            }
+            if (value instanceof Object) {
+                return querystring(value as HTTPQuery, fullKey);
+            }
+            return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+        })
+        .filter(part => part.length > 0)
+        .join('&');
+}
+
+export function mapValues(data: any, fn: (item: any) => any) {
+  return Object.keys(data).reduce(
+    (acc, key) => ({ ...acc, [key]: fn(data[key]) }),
+    {}
+  );
+}
+
+export function canConsumeForm(consumes: Consume[]): boolean {
+    for (const consume of consumes) {
+        if ('multipart/form-data' === consume.contentType) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export interface Consume {
+    contentType: string
+}
+
+export interface RequestContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+}
+
+export interface ResponseContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    response: Response;
+}
+
+export interface Middleware {
+    pre?(context: RequestContext): Promise<FetchParams | void>;
+    post?(context: ResponseContext): Promise<Response | void>;
+}
+
+export interface ApiResponse<T> {
+    raw: Response;
+    value(): Promise<T>;
+}
+
+export interface ResponseTransformer<T> {
+    (json: any): T;
+}
+
+export class JSONApiResponse<T> {
+    constructor(public raw: Response, private transformer: ResponseTransformer<T> = (jsonValue: any) => jsonValue) {}
+
+    async value(): Promise<T> {
+        return this.transformer(await this.raw.json());
+    }
+}
+
+export class VoidApiResponse {
+    constructor(public raw: Response) {}
+
+    async value(): Promise<void> {
+        return undefined;
+    }
+}
+
+export class BlobApiResponse {
+    constructor(public raw: Response) {}
+
+    async value(): Promise<Blob> {
+        return await this.raw.blob();
+    };
+}
+
+export class TextApiResponse {
+    constructor(public raw: Response) {}
+
+    async value(): Promise<string> {
+        return await this.raw.text();
+    };
+}