@aws/nx-plugin 0.11.0 → 0.13.0

package/src/open-api/ts-client/__snapshots__/generator.spec.ts.snap

@@ -11,7 +11,7 @@ exports[`openApiTsClientGenerator > should allow duplicate operation ids discrim
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 }
 
@@ -19,8 +19,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -31,6 +49,9 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this._itemsStockList = this._itemsStockList.bind(this);
+    this._usersPeopleList = this._usersPeopleList.bind(this);
   }
 
   private $url = (
@@ -79,10 +100,10 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  private _itemsStockList = async (): Promise<Array<string>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _itemsStockList(): Promise<Array<string>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -96,17 +117,17 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()) as Array<string>;
+      return await response.json();
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  private _usersPeopleList = async (): Promise<Array<string>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _usersPeopleList(): Promise<Array<string>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -120,39 +141,39 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()) as Array<string>;
+      return await response.json();
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
   /**
    * items operations
    */
   public items = {
-    list: this._itemsStockList,
+    list: this._itemsStockList.bind(this),
   };
 
   /**
    * stock operations
    */
   public stock = {
-    list: this._itemsStockList,
+    list: this._itemsStockList.bind(this),
   };
 
   /**
    * users operations
    */
   public users = {
-    list: this._usersPeopleList,
+    list: this._usersPeopleList.bind(this),
   };
 
   /**
    * people operations
    */
   public people = {
-    list: this._usersPeopleList,
+    list: this._usersPeopleList.bind(this),
   };
 }
 "
@@ -169,7 +190,7 @@ exports[`openApiTsClientGenerator > should allow duplicate operation ids discrim
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 }
 
@@ -177,8 +198,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -189,6 +228,9 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this._itemsList = this._itemsList.bind(this);
+    this._usersList = this._usersList.bind(this);
   }
 
   private $url = (
@@ -237,10 +279,10 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  private _itemsList = async (): Promise<Array<string>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _itemsList(): Promise<Array<string>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -254,17 +296,17 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()) as Array<string>;
+      return await response.json();
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  private _usersList = async (): Promise<Array<string>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _usersList(): Promise<Array<string>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -278,25 +320,25 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()) as Array<string>;
+      return await response.json();
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
   /**
    * items operations
    */
   public items = {
-    list: this._itemsList,
+    list: this._itemsList.bind(this),
   };
 
   /**
    * users operations
    */
   public users = {
-    list: this._usersList,
+    list: this._usersList.bind(this),
   };
 }
 "
@@ -335,7 +377,7 @@ exports[`openApiTsClientGenerator > should generate valid TypeScript for arrays
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostTest200ResponseItem = {
@@ -395,7 +437,7 @@ class $IO {
         ...(model.complexDict === undefined
           ? {}
           : {
-              complexDict: $IO.mapValues(
+              complexDict: $IO.$mapValues(
                 model.complexDict,
                 $IO.PostTestRequestContentComplexDictValue.toJson,
               ),
@@ -425,7 +467,7 @@ class $IO {
         ...(json['complexDict'] === undefined
           ? {}
           : {
-              complexDict: $IO.mapValues(
+              complexDict: $IO.$mapValues(
                 json['complexDict'],
                 $IO.PostTestRequestContentComplexDictValue.fromJson,
               ),
@@ -468,8 +510,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -480,6 +540,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postTest = this.postTest.bind(this);
   }
 
   private $url = (
@@ -528,12 +590,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postTest = async (
+  public async postTest(
     input?: PostTestRequest,
-  ): Promise<Array<PostTest200ResponseItem>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<Array<PostTest200ResponseItem>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -551,12 +616,14 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()).map($IO.PostTest200ResponseItem.fromJson);
+      return ((await response.json()) as Array<any>).map(
+        $IO.PostTest200ResponseItem.fromJson,
+      );
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -610,7 +677,7 @@ exports[`openApiTsClientGenerator > should generate valid TypeScript for composi
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PutTest200Response = {
@@ -803,8 +870,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -815,6 +900,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.putTest = this.putTest.bind(this);
   }
 
   private $url = (
@@ -863,12 +950,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public putTest = async (
-    input?: PutTestRequest,
-  ): Promise<PutTest200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async putTest(input?: PutTestRequest): Promise<PutTest200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -891,7 +979,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -943,7 +1031,7 @@ exports[`openApiTsClientGenerator > should generate valid TypeScript for paramet
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static GetTest200Response = {
@@ -1088,8 +1176,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -1100,6 +1206,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.getTest = this.getTest.bind(this);
   }
 
   private $url = (
@@ -1148,12 +1256,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public getTest = async (
-    input: GetTestRequest,
-  ): Promise<GetTest200Response> => {
-    const pathParameters = $IO.GetTestRequestPathParameters.toJson(input);
-    const queryParameters = $IO.GetTestRequestQueryParameters.toJson(input);
-    const headerParameters = $IO.GetTestRequestHeaderParameters.toJson(input);
+  public async getTest(input: GetTestRequest): Promise<GetTest200Response> {
+    const pathParameters: { [key: string]: any } =
+      $IO.GetTestRequestPathParameters.toJson(input);
+    const queryParameters: { [key: string]: any } =
+      $IO.GetTestRequestQueryParameters.toJson(input);
+    const headerParameters: { [key: string]: any } =
+      $IO.GetTestRequestHeaderParameters.toJson(input);
     const collectionFormats = {
       'x-api-key': 'csv',
       filter: 'multi',
@@ -1193,7 +1302,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -1218,7 +1327,7 @@ exports[`openApiTsClientGenerator > should generate valid TypeScript for primiti
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static GetTest200Response = {
@@ -1290,8 +1399,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -1302,6 +1429,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.getTest = this.getTest.bind(this);
   }
 
   private $url = (
@@ -1353,10 +1482,10 @@ export class TestApi {
   /**
    * Sends a test request!
    */
-  public getTest = async (): Promise<GetTest200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async getTest(): Promise<GetTest200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -1375,7 +1504,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -1418,7 +1547,7 @@ exports[`openApiTsClientGenerator > should handle composite primitive and array
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static CompositeRequestContent = {
@@ -1453,7 +1582,7 @@ class $IO {
         ...(model === null ? null : model),
         ...(model === null
           ? null
-          : $IO.mapValues(
+          : $IO.$mapValues(
               model,
               $IO.CompositeRequestContentOneOf3Value.toJson,
             )),
@@ -1495,7 +1624,7 @@ class $IO {
         ...(json === null ? null : json),
         ...(json === null
           ? null
-          : $IO.mapValues(
+          : $IO.$mapValues(
               json,
               $IO.CompositeRequestContentOneOf3Value.fromJson,
             )),
@@ -1590,8 +1719,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -1602,6 +1749,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.composite = this.composite.bind(this);
   }
 
   private $url = (
@@ -1650,10 +1799,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public composite = async (input?: CompositeRequest): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async composite(input?: CompositeRequest): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -1676,7 +1828,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -1713,7 +1865,7 @@ exports[`openApiTsClientGenerator > should handle date and date-time formats 2`]
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostDates200Response = {
@@ -1815,8 +1967,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -1827,6 +1997,9 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postDates = this.postDates.bind(this);
+    this.postSingleDate = this.postSingleDate.bind(this);
   }
 
   private $url = (
@@ -1875,12 +2048,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postDates = async (
+  public async postDates(
     input?: PostDatesRequest,
-  ): Promise<PostDates200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<PostDates200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -1903,14 +2079,15 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postSingleDate = async (
-    input: PostSingleDateRequest,
-  ): Promise<Date> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async postSingleDate(input: PostSingleDateRequest): Promise<Date> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input.toISOString().slice(0, 10);
 
     const response = await this.$fetch(
@@ -1928,7 +2105,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -1958,7 +2135,7 @@ exports[`openApiTsClientGenerator > should handle default responses 2`] = `
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static GetTest200Response = {
@@ -2012,8 +2189,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -2024,6 +2219,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.getTest = this.getTest.bind(this);
   }
 
   private $url = (
@@ -2072,10 +2269,10 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public getTest = async (): Promise<GetTest200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async getTest(): Promise<GetTest200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -2095,7 +2292,7 @@ export class TestApi {
       status: response.status,
       error: $IO.GetTestdefaultResponse.fromJson(await response.json()),
     };
-  };
+  }
 }
 "
 `;
@@ -2124,7 +2321,7 @@ exports[`openApiTsClientGenerator > should handle enum request and response bodi
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 }
 
@@ -2132,8 +2329,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -2144,6 +2359,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.updateStatus = this.updateStatus.bind(this);
   }
 
   private $url = (
@@ -2192,12 +2409,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public updateStatus = async (
+  public async updateStatus(
     input: UpdateStatusRequest,
-  ): Promise<UpdateStatus200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<UpdateStatus200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input;
 
     const response = await this.$fetch(
@@ -2215,7 +2435,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -2291,7 +2511,7 @@ exports[`openApiTsClientGenerator > should handle inline primitives and composit
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static TestArrays200Response = {
@@ -2505,8 +2725,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -2517,6 +2755,14 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.testArrays = this.testArrays.bind(this);
+    this.testArraysWithOtherParameters =
+      this.testArraysWithOtherParameters.bind(this);
+    this.testComposites = this.testComposites.bind(this);
+    this.testEnums = this.testEnums.bind(this);
+    this.testPrimitiveBinary = this.testPrimitiveBinary.bind(this);
+    this.testPrimitiveText = this.testPrimitiveText.bind(this);
   }
 
   private $url = (
@@ -2565,12 +2811,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public testArrays = async (
+  public async testArrays(
     input?: TestArraysRequest,
-  ): Promise<TestArrays200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<TestArrays200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -2593,15 +2842,18 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public testArraysWithOtherParameters = async (
+  public async testArraysWithOtherParameters(
     input: TestArraysWithOtherParametersRequest,
-  ): Promise<TestArraysWithOtherParameters200Response> => {
-    const pathParameters = {};
-    const queryParameters =
+  ): Promise<TestArraysWithOtherParameters200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } =
       $IO.TestArraysWithOtherParametersRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       someParameter: 'multi',
     } as const;
@@ -2642,14 +2894,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public testComposites = async (
+  public async testComposites(
     input?: TestCompositesRequest,
-  ): Promise<TestComposites200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<TestComposites200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -2672,12 +2927,12 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public testEnums = async (): Promise<TestEnums200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async testEnums(): Promise<TestEnums200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -2696,14 +2951,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public testPrimitiveBinary = async (
+  public async testPrimitiveBinary(
     input: TestPrimitiveBinaryRequest,
-  ): Promise<Blob> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<Blob> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/octet-stream';
+    }
     const body = input;
 
     const response = await this.$fetch(
@@ -2721,14 +2979,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public testPrimitiveText = async (
+  public async testPrimitiveText(
     input: TestPrimitiveTextRequest,
-  ): Promise<number> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<number> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = String(input);
 
     const response = await this.$fetch(
@@ -2746,7 +3007,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -2893,7 +3154,7 @@ exports[`openApiTsClientGenerator > should handle multiple response status codes
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static TestResponses2XXResponse = {
@@ -3019,8 +3280,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -3031,6 +3310,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.testResponses = this.testResponses.bind(this);
   }
 
   private $url = (
@@ -3079,12 +3360,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public testResponses = async (
+  public async testResponses(
     input?: TestResponsesRequest,
-  ): Promise<TestResponses2XXResponse> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<TestResponses2XXResponse> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -3119,7 +3403,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -3153,7 +3437,7 @@ exports[`openApiTsClientGenerator > should handle not schema type 2`] = `
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static TestNot200Response = {
@@ -3252,8 +3536,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -3264,6 +3566,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.testNot = this.testNot.bind(this);
   }
 
   private $url = (
@@ -3312,12 +3616,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public testNot = async (
-    input?: TestNotRequest,
-  ): Promise<TestNot200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async testNot(input?: TestNotRequest): Promise<TestNot200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -3340,7 +3645,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -3443,7 +3748,7 @@ exports[`openApiTsClientGenerator > should handle nullable schemas in various co
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostSingleNullableObjectRequestContent = {
@@ -3966,8 +4271,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -3978,6 +4301,13 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postSingleNullableArray = this.postSingleNullableArray.bind(this);
+    this.postSingleNullableBoolean = this.postSingleNullableBoolean.bind(this);
+    this.postSingleNullableNumber = this.postSingleNullableNumber.bind(this);
+    this.postSingleNullableObject = this.postSingleNullableObject.bind(this);
+    this.postSingleNullableString = this.postSingleNullableString.bind(this);
+    this.testNullable = this.testNullable.bind(this);
   }
 
   private $url = (
@@ -4026,12 +4356,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postSingleNullableArray = async (
+  public async postSingleNullableArray(
     input?: PostSingleNullableArrayRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -4054,14 +4387,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postSingleNullableBoolean = async (
+  public async postSingleNullableBoolean(
     input?: PostSingleNullableBooleanRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input === undefined ? undefined : String(input);
 
     const response = await this.$fetch(
@@ -4079,14 +4415,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postSingleNullableNumber = async (
+  public async postSingleNullableNumber(
     input?: PostSingleNullableNumberRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input === undefined ? undefined : String(input);
 
     const response = await this.$fetch(
@@ -4104,14 +4443,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postSingleNullableObject = async (
+  public async postSingleNullableObject(
     input?: PostSingleNullableObjectRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -4136,14 +4478,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postSingleNullableString = async (
+  public async postSingleNullableString(
     input?: PostSingleNullableStringRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input === undefined ? undefined : String(input);
 
     const response = await this.$fetch(
@@ -4161,15 +4506,19 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public testNullable = async (
+  public async testNullable(
     input: TestNullableRequest,
-  ): Promise<TestNullable200Response> => {
-    const pathParameters = $IO.TestNullableRequestPathParameters.toJson(input);
-    const queryParameters =
+  ): Promise<TestNullable200Response> {
+    const pathParameters: { [key: string]: any } =
+      $IO.TestNullableRequestPathParameters.toJson(input);
+    const queryParameters: { [key: string]: any } =
       $IO.TestNullableRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       queryString: 'multi',
       queryNumber: 'multi',
@@ -4205,7 +4554,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -4239,7 +4588,7 @@ exports[`openApiTsClientGenerator > should handle number and string constraints
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static TestConstraints200Response = {
@@ -4343,8 +4692,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -4355,6 +4722,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.testConstraints = this.testConstraints.bind(this);
   }
 
   private $url = (
@@ -4403,12 +4772,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public testConstraints = async (
+  public async testConstraints(
     input?: TestConstraintsRequest,
-  ): Promise<TestConstraints200Response> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<TestConstraints200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -4431,7 +4803,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -4451,7 +4823,7 @@ exports[`openApiTsClientGenerator > should handle only default response 2`] = `
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static GetTestdefaultResponse = {
@@ -4482,8 +4854,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -4494,6 +4884,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.getTest = this.getTest.bind(this);
   }
 
   private $url = (
@@ -4542,10 +4934,10 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public getTest = async (): Promise<GetTestdefaultResponse> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async getTest(): Promise<GetTestdefaultResponse> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -4559,7 +4951,7 @@ export class TestApi {
     );
 
     return $IO.GetTestdefaultResponse.fromJson(await response.json());
-  };
+  }
 }
 "
 `;
@@ -4577,7 +4969,7 @@ exports[`openApiTsClientGenerator > should handle operation tags and multiple se
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 }
 
@@ -4585,8 +4977,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -4597,6 +5007,11 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this._createUser = this._createUser.bind(this);
+    this._getItems = this._getItems.bind(this);
+    this.getStatus = this.getStatus.bind(this);
+    this._getUsers = this._getUsers.bind(this);
   }
 
   private $url = (
@@ -4645,10 +5060,10 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  private _createUser = async (): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _createUser(): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -4667,15 +5082,15 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
   /**
    * Returns a list of all the items
    */
-  private _getItems = async (): Promise<Array<string>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _getItems(): Promise<Array<string>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -4689,17 +5104,17 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()) as Array<string>;
+      return await response.json();
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public getStatus = async (): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async getStatus(): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -4718,12 +5133,12 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  private _getUsers = async (): Promise<Array<string>> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _getUsers(): Promise<Array<string>> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -4737,19 +5152,19 @@ export class TestApi {
     );
 
     if (response.status === 200) {
-      return (await response.json()) as Array<string>;
+      return await response.json();
     }
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
   /**
    * users operations
    */
   public users = {
-    createUser: this._createUser,
-    getUsers: this._getUsers,
+    createUser: this._createUser.bind(this),
+    getUsers: this._getUsers.bind(this),
   };
 
   /**
@@ -4759,7 +5174,7 @@ export class TestApi {
     /**
      * Returns a list of all the items
      */
-    getItems: this._getItems,
+    getItems: this._getItems.bind(this),
   };
 }
 "
@@ -4849,7 +5264,7 @@ exports[`openApiTsClientGenerator > should handle operations with complex map ty
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostMapOfArraysOfObjectsRequestContent = {
@@ -4858,7 +5273,7 @@ class $IO {
         return model;
       }
       return {
-        ...$IO.mapValues(model, (item0) =>
+        ...$IO.$mapValues(model, (item0) =>
           item0.map($IO.PostMapOfArraysOfObjectsRequestContentValueItem.toJson),
         ),
       };
@@ -4868,7 +5283,7 @@ class $IO {
         return json;
       }
       return {
-        ...$IO.mapValues(json, (item0) =>
+        ...$IO.$mapValues(json, (item0) =>
           item0.map(
             $IO.PostMapOfArraysOfObjectsRequestContentValueItem.fromJson,
           ),
@@ -4969,7 +5384,10 @@ class $IO {
         return model;
       }
       return {
-        ...$IO.mapValues(model, $IO.PostMapOfObjectsRequestContentValue.toJson),
+        ...$IO.$mapValues(
+          model,
+          $IO.PostMapOfObjectsRequestContentValue.toJson,
+        ),
       };
     },
     fromJson: (json: any): PostMapOfObjectsRequestContent => {
@@ -4977,7 +5395,7 @@ class $IO {
         return json;
       }
       return {
-        ...$IO.mapValues(
+        ...$IO.$mapValues(
           json,
           $IO.PostMapOfObjectsRequestContentValue.fromJson,
         ),
@@ -5019,8 +5437,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -5031,6 +5467,16 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postArrayOfMapsOfArraysOfNumbers =
+      this.postArrayOfMapsOfArraysOfNumbers.bind(this);
+    this.postArrayOfMapsOfNumbers = this.postArrayOfMapsOfNumbers.bind(this);
+    this.postMapOfArraysOfObjects = this.postMapOfArraysOfObjects.bind(this);
+    this.postMapOfMapsOfArraysOfNumbers =
+      this.postMapOfMapsOfArraysOfNumbers.bind(this);
+    this.postMapOfMapsOfNumbers = this.postMapOfMapsOfNumbers.bind(this);
+    this.postMapOfNumbers = this.postMapOfNumbers.bind(this);
+    this.postMapOfObjects = this.postMapOfObjects.bind(this);
   }
 
   private $url = (
@@ -5079,12 +5525,15 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postArrayOfMapsOfArraysOfNumbers = async (
+  public async postArrayOfMapsOfArraysOfNumbers(
     input?: PostArrayOfMapsOfArraysOfNumbersRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5111,14 +5560,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postArrayOfMapsOfNumbers = async (
+  public async postArrayOfMapsOfNumbers(
     input?: PostArrayOfMapsOfNumbersRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5141,14 +5593,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postMapOfArraysOfObjects = async (
+  public async postMapOfArraysOfObjects(
     input?: PostMapOfArraysOfObjectsRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5173,14 +5628,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postMapOfMapsOfArraysOfNumbers = async (
+  public async postMapOfMapsOfArraysOfNumbers(
     input?: PostMapOfMapsOfArraysOfNumbersRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5211,14 +5669,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postMapOfMapsOfNumbers = async (
+  public async postMapOfMapsOfNumbers(
     input?: PostMapOfMapsOfNumbersRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5243,14 +5704,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postMapOfNumbers = async (
+  public async postMapOfNumbers(
     input?: PostMapOfNumbersRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5273,14 +5737,17 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postMapOfObjects = async (
+  public async postMapOfObjects(
     input?: PostMapOfObjectsRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -5303,7 +5770,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -5319,7 +5786,7 @@ exports[`openApiTsClientGenerator > should handle operations with multiple tags
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 }
 
@@ -5327,8 +5794,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -5339,6 +5824,9 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this._getMultiTagged = this._getMultiTagged.bind(this);
+    this._postMultiTagged = this._postMultiTagged.bind(this);
   }
 
   private $url = (
@@ -5387,10 +5875,10 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  private _getMultiTagged = async (): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _getMultiTagged(): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -5409,12 +5897,12 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  private _postMultiTagged = async (): Promise<number> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  private async _postMultiTagged(): Promise<number> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -5433,29 +5921,29 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
   /**
    * tag1 operations
    */
   public tag1 = {
-    getMultiTagged: this._getMultiTagged,
-    postMultiTagged: this._postMultiTagged,
+    getMultiTagged: this._getMultiTagged.bind(this),
+    postMultiTagged: this._postMultiTagged.bind(this),
   };
 
   /**
    * tag2 operations
    */
   public tag2 = {
-    getMultiTagged: this._getMultiTagged,
+    getMultiTagged: this._getMultiTagged.bind(this),
   };
 
   /**
    * tag3 operations
    */
   public tag3 = {
-    getMultiTagged: this._getMultiTagged,
-    postMultiTagged: this._postMultiTagged,
+    getMultiTagged: this._getMultiTagged.bind(this),
+    postMultiTagged: this._postMultiTagged.bind(this),
   };
 }
 "
@@ -5527,7 +6015,7 @@ exports[`openApiTsClientGenerator > should handle operations with simple request
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostBooleanWithQueryRequestBodyParameters = {
@@ -5697,8 +6185,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -5709,6 +6215,13 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postBoolean = this.postBoolean.bind(this);
+    this.postBooleanWithQuery = this.postBooleanWithQuery.bind(this);
+    this.postNumber = this.postNumber.bind(this);
+    this.postNumberWithQuery = this.postNumberWithQuery.bind(this);
+    this.postString = this.postString.bind(this);
+    this.postStringWithQuery = this.postStringWithQuery.bind(this);
   }
 
   private $url = (
@@ -5757,10 +6270,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postBoolean = async (input?: PostBooleanRequest): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async postBoolean(input?: PostBooleanRequest): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input === undefined ? undefined : String(input);
 
     const response = await this.$fetch(
@@ -5778,15 +6294,18 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postBooleanWithQuery = async (
+  public async postBooleanWithQuery(
     input: PostBooleanWithQueryRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters =
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } =
       $IO.PostBooleanWithQueryRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       filter: 'multi',
     } as const;
@@ -5812,12 +6331,15 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postNumber = async (input?: PostNumberRequest): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async postNumber(input?: PostNumberRequest): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input === undefined ? undefined : String(input);
 
     const response = await this.$fetch(
@@ -5835,15 +6357,18 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postNumberWithQuery = async (
+  public async postNumberWithQuery(
     input: PostNumberWithQueryRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters =
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } =
       $IO.PostNumberWithQueryRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       filter: 'multi',
     } as const;
@@ -5869,12 +6394,15 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postString = async (input?: PostStringRequest): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async postString(input?: PostStringRequest): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body = input === undefined ? undefined : String(input);
 
     const response = await this.$fetch(
@@ -5892,15 +6420,18 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public postStringWithQuery = async (
+  public async postStringWithQuery(
     input: PostStringWithQueryRequest,
-  ): Promise<string> => {
-    const pathParameters = {};
-    const queryParameters =
+  ): Promise<string> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } =
       $IO.PostStringWithQueryRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       filter: 'multi',
     } as const;
@@ -5926,7 +6457,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -5951,7 +6482,7 @@ exports[`openApiTsClientGenerator > should handle recursive schema references 2`
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static TreeNode = {
@@ -6000,8 +6531,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -6012,6 +6561,9 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.createTree = this.createTree.bind(this);
+    this.getTree = this.getTree.bind(this);
   }
 
   private $url = (
@@ -6060,10 +6612,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public createTree = async (input?: CreateTreeRequest): Promise<TreeNode> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async createTree(input?: CreateTreeRequest): Promise<TreeNode> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       input === undefined
         ? undefined
@@ -6086,12 +6641,12 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 
-  public getTree = async (): Promise<TreeNode> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async getTree(): Promise<TreeNode> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
 
     const body = undefined;
 
@@ -6110,7 +6665,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -6155,7 +6710,7 @@ exports[`openApiTsClientGenerator > should handle refs and hoisting of inline sc
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static Error = {
@@ -6307,8 +6862,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -6319,6 +6892,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postTest = this.postTest.bind(this);
   }
 
   private $url = (
@@ -6367,10 +6942,13 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postTest = async (input: PostTestRequest): Promise<void> => {
-    const pathParameters = {};
-    const queryParameters = {};
-    const headerParameters = {};
+  public async postTest(input: PostTestRequest): Promise<void> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } = {};
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const body =
       typeof input === 'object'
         ? JSON.stringify($IO.PostTestRequestContent.toJson(input))
@@ -6397,7 +6975,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -6440,7 +7018,7 @@ exports[`openApiTsClientGenerator > should handle request body property matching
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostTest200Response = {
@@ -6585,8 +7163,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -6597,6 +7193,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postTest = this.postTest.bind(this);
   }
 
   private $url = (
@@ -6645,12 +7243,14 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postTest = async (
-    input: PostTestRequest,
-  ): Promise<PostTest200Response> => {
-    const pathParameters = {};
-    const queryParameters = $IO.PostTestRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+  public async postTest(input: PostTestRequest): Promise<PostTest200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } =
+      $IO.PostTestRequestQueryParameters.toJson(input);
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       filter: 'multi',
     } as const;
@@ -6676,7 +7276,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;
@@ -6718,7 +7318,7 @@ exports[`openApiTsClientGenerator > should handle special formats and vendor ext
  * Utility for serialisation and deserialisation of API types.
  */
 class $IO {
-  private static mapValues = (data: any, fn: (item: any) => any) =>
+  protected static $mapValues = (data: any, fn: (item: any) => any) =>
     Object.fromEntries(Object.entries(data).map(([k, v]) => [k, fn(v)]));
 
   public static PostTest200Response = {
@@ -6887,8 +7487,26 @@ class $IO {
  * Client configuration for TestApi
  */
 export interface TestApiConfig {
+  /**
+   * Base URL for the API
+   */
   url: string;
+  /**
+   * Custom instance of fetch. By default the global 'fetch' is used.
+   * You can override this to add custom middleware for use cases such as adding authentication headers.
+   */
   fetch?: typeof fetch;
+  /**
+   * Additional configuration
+   */
+  options?: {
+    /**
+     * By default, the client will add a Content-Type header, set to the media type defined for
+     * the request in the OpenAPI specification.
+     * Set this to false to omit this header.
+     */
+    omitContentTypeHeader?: boolean;
+  };
 }
 
 /**
@@ -6899,6 +7517,8 @@ export class TestApi {
 
   constructor(config: TestApiConfig) {
     this.$config = config;
+
+    this.postTest = this.postTest.bind(this);
   }
 
   private $url = (
@@ -6947,12 +7567,14 @@ export class TestApi {
   private $fetch: typeof fetch = (...args) =>
     (this.$config.fetch ?? fetch)(...args);
 
-  public postTest = async (
-    input: PostTestRequest,
-  ): Promise<PostTest200Response> => {
-    const pathParameters = {};
-    const queryParameters = $IO.PostTestRequestQueryParameters.toJson(input);
-    const headerParameters = {};
+  public async postTest(input: PostTestRequest): Promise<PostTest200Response> {
+    const pathParameters: { [key: string]: any } = {};
+    const queryParameters: { [key: string]: any } =
+      $IO.PostTestRequestQueryParameters.toJson(input);
+    const headerParameters: { [key: string]: any } = {};
+    if (!this.$config.options?.omitContentTypeHeader) {
+      headerParameters['Content-Type'] = 'application/json';
+    }
     const collectionFormats = {
       date: 'multi',
       timestamp: 'multi',
@@ -6979,7 +7601,7 @@ export class TestApi {
     throw new Error(
       \`Unknown response status \${response.status} returned by API\`,
     );
-  };
+  }
 }
 "
 `;