diff --git a/src/generators/typescript/fetch/sigil_emit_api.rs b/src/generators/typescript/fetch/sigil_emit_api.rs
index 95566457..722f4a93 100644
--- a/src/generators/typescript/fetch/sigil_emit_api.rs
+++ b/src/generators/typescript/fetch/sigil_emit_api.rs
@@ -2,8 +2,7 @@
 //!
 //! Produces one `FileSpec` per tag containing:
 //! - request interfaces (one per operation that has parameters)
-//! - `{Tag}ApiInterface` — method arrow-function signatures (emitted as a raw
-//!   `CodeBlock` so `%T` slots can carry import tracking for every type ref)
+//! - `{Tag}ApiInterface` — structural callable properties with named parameters
 //! - `{Tag}Api` class extending `BaseAPI` with constructor + real Raw +
 //!   convenience methods
 //!
@@ -12,9 +11,9 @@
 //! Every named reference (model types, runtime wrappers) is routed through a
 //! structural [`TypeName`] (via `importable` for runtime-value symbols like
 //! `BaseAPI` / `JSONApiResponse`, `importable_type` for pure TS types like
-//! `Configuration`). Object-literal fragments like `{ status: 200 }` stay as
-//! `TypeName::raw`. Method bodies use `CodeBlock::add(fmt, [%T, %L, ...])` so
-//! sigil resolves all imports in one pass.
+//! `Configuration`). Callable parameter and return types remain structural
+//! through rendering. Object-literal fragments like `{ status: 200 }` still
+//! use a bounded `TypeName::raw` escape hatch.
 
 use std::collections::{BTreeMap, BTreeSet, HashSet};
 
@@ -43,6 +42,7 @@ use sigil_stitch::spec::fun_spec::FunSpec;
 use sigil_stitch::spec::modifiers::{DeclarationContext, TypeKind, Visibility};
 use sigil_stitch::spec::parameter_spec::ParameterSpec;
 use sigil_stitch::spec::type_spec::TypeSpec;
+use sigil_stitch::spec::where_spec::{CallableParam, CallableParamPresence};
 use sigil_stitch::type_name::TypeName;
 
 use super::sigil_emit::{EmitFlags, build_convertible_set, fn_base_name};
@@ -181,12 +181,7 @@ fn emit_api_file(
     }
     fb = fb.add_code(build_error_types_block(ops, ir)?);
 
-    // ApiInterface — emit as a raw CodeBlock so `%T` slots propagate imports
-    // for every arrow-function parameter and return type. (TypeSpec with
-    // FieldSpec arrow-function fields can't carry structural TypeName for the
-    // whole `(p: T) => R` shape because sigil's `TypeName::function` doesn't
-    // emit parameter names.)
-    fb = fb.add_code(build_api_interface_block(&interface_name, ops)?);
+    fb = fb.add_type(build_api_interface(&interface_name, ops)?);
 
     // When property_naming_camel_case is enabled, add explicit imports for
     // converter functions and $Wire types referenced in raw code blocks.
@@ -515,8 +510,7 @@ fn build_request_interface(
         return None;
     }
 
-    let method_base = op.operation_id.to_lower_camel_case();
-    let interface_name = format!("Api{}Request", method_base.to_pascal_case());
+    let interface_name = request_interface_name(op);
     let names = resolve_param_names(op);
 
     let mut tb =
@@ -614,70 +608,50 @@ fn build_body_field(
 }
 
 // ============================================================================
-// ApiInterface (raw CodeBlock with %T slots)
+// ApiInterface
 // ============================================================================
 
-fn build_api_interface_block(
+fn build_api_interface(
     interface_name: &str,
     ops: &[&IrOperation],
-) -> Result<CodeBlock, SigilStitchError> {
-    let mut cb = CodeBlock::builder();
-    cb.add(&format!("export interface {} {{\n", interface_name), vec![]);
+) -> Result<TypeSpec, SigilStitchError> {
+    let mut interface =
+        TypeSpec::builder(interface_name, TypeKind::Interface).visibility(Visibility::Public);
 
     for op in ops {
         let method_base = op.operation_id.to_lower_camel_case();
         let raw_name = format!("{}Raw", method_base);
 
-        cb.add(&format!("  {}: ", raw_name), vec![]);
-        emit_arrow_signature(&mut cb, op, raw_return_type(op));
-        cb.add(";\n", vec![]);
-
-        cb.add(&format!("  {}: ", method_base), vec![]);
-        emit_arrow_signature(
-            &mut cb,
-            op,
-            type_application(
-                TypeName::primitive("Promise"),
-                vec![convenience_body_type(op)],
-            ),
+        interface = interface.add_field(
+            FieldSpec::builder(&raw_name, api_callable_type(op, raw_return_type(op))).build()?,
+        );
+        let return_type = type_application(
+            TypeName::primitive("Promise"),
+            vec![convenience_body_type(op)],
+        );
+        interface = interface.add_field(
+            FieldSpec::builder(&method_base, api_callable_type(op, return_type)).build()?,
         );
-        cb.add(";\n", vec![]);
     }
 
-    cb.add("}", vec![]);
-    cb.build()
+    interface.build()
 }
 
-/// Append `(requestParameters: ApiXRequest, initOverrides?: RequestInit | InitOverrideFunction) => %T`
-/// onto the given block, using `%T` slots for every named type so imports
-/// flow through.
-fn emit_arrow_signature(
-    cb: &mut sigil_stitch::code_block::CodeBlockBuilder,
-    op: &IrOperation,
-    return_ty: TypeName,
-) {
-    let mut parts: Vec<String> = Vec::new();
-    let mut args: Vec<Arg> = Vec::new();
-
+fn api_callable_type(op: &IrOperation, return_type: TypeName) -> TypeName {
+    let mut parameters = Vec::new();
     if operation_has_params(op) {
-        let iface = format!(
-            "Api{}Request",
-            op.operation_id.to_lower_camel_case().to_pascal_case()
-        );
-        parts.push(format!("requestParameters: {}", iface));
-    }
-    // initOverrides?: RequestInit | InitOverrideFunction
-    parts.push("initOverrides?: RequestInit | %T".to_string());
-    args.push(Arg::TypeName(TypeName::importable_type(
-        RUNTIME_MOD,
-        "InitOverrideFunction",
-    )));
-
-    cb.add(&format!("({}) => %T", parts.join(", ")), {
-        let mut merged = args;
-        merged.push(Arg::TypeName(return_ty));
-        merged
+        parameters.push(CallableParam::Single {
+            name: Some("requestParameters".to_string()),
+            type_name: TypeName::primitive(&request_interface_name(op)),
+            presence: CallableParamPresence::Required,
+        });
+    }
+    parameters.push(CallableParam::Single {
+        name: Some("initOverrides".to_string()),
+        type_name: init_overrides_type(),
+        presence: CallableParamPresence::Optional,
     });
+    TypeName::callable(parameters, vec![return_type])
 }
 
 // ============================================================================
@@ -695,7 +669,7 @@ fn build_api_class(
     let mut tb = TypeSpec::builder(class_name, TypeKind::Class)
         .visibility(Visibility::Public)
         .extends(rt_value("BaseAPI"))
-        .implements(TypeName::raw(interface_name))
+        .implements(TypeName::primitive(interface_name))
         .add_method(build_constructor());
 
     for op in ops {
@@ -1569,12 +1543,9 @@ fn is_primitive_type(ty: &TypeName, primitive: &str) -> bool {
 fn method_param_specs(op: &IrOperation) -> Vec<ParameterSpec> {
     let mut out = Vec::new();
     if operation_has_params(op) {
-        let iface_name = format!(
-            "Api{}Request",
-            op.operation_id.to_lower_camel_case().to_pascal_case()
-        );
+        let iface_name = request_interface_name(op);
         out.push(
-            ParameterSpec::builder("requestParameters", TypeName::raw(&iface_name))
+            ParameterSpec::builder("requestParameters", TypeName::primitive(&iface_name))
                 .build()
                 .expect("ParameterSpec builds"),
         );
@@ -1583,6 +1554,13 @@ fn method_param_specs(op: &IrOperation) -> Vec<ParameterSpec> {
     out
 }
 
+fn request_interface_name(op: &IrOperation) -> String {
+    format!(
+        "Api{}Request",
+        op.operation_id.to_lower_camel_case().to_pascal_case()
+    )
+}
+
 fn init_overrides_param() -> ParameterSpec {
     ParameterSpec::builder("initOverrides?", init_overrides_type())
         .build()
@@ -1621,7 +1599,7 @@ fn raw_return_type(op: &IrOperation) -> TypeName {
     // same file (see `build_response_aliases_block`) so no import is needed.
     type_application(
         TypeName::primitive("Promise"),
-        vec![TypeName::raw(&raw_response_alias_name(op))],
+        vec![TypeName::primitive(&raw_response_alias_name(op))],
     )
 }
 
@@ -2299,6 +2277,123 @@ mod tests {
         crate::ir::lower::lower(parsed).expect("response dispatch fixture lowers")
     }
 
+    fn api_interface_ir() -> IrSpec {
+        let parsed = crate::parser::parse_content_yaml(include_str!(
+            "../../../../tests/fixtures/valid/typescript-api-interface.yaml"
+        ))
+        .expect("API interface fixture parses");
+        crate::ir::lower::lower(parsed).expect("API interface fixture lowers")
+    }
+
+    #[test]
+    fn api_callable_parameters_preserve_request_and_override_presence() {
+        let ir = api_interface_ir();
+        for op in &ir.operations {
+            let return_type = raw_return_type(op);
+            let TypeName::Callable {
+                parameters,
+                returns,
+            } = api_callable_type(op, return_type.clone())
+            else {
+                panic!("API properties must retain structural callable types");
+            };
+            assert_eq!(returns, vec![return_type]);
+            assert_eq!(
+                parameters.last(),
+                Some(&CallableParam::Single {
+                    name: Some("initOverrides".to_string()),
+                    type_name: init_overrides_type(),
+                    presence: CallableParamPresence::Optional,
+                })
+            );
+            match op.operation_id.as_str() {
+                "noInput" | "cookieInput" => assert_eq!(parameters.len(), 1),
+                "optionalInput" | "submit" | "getEntries" => {
+                    assert_eq!(parameters.len(), 2);
+                    assert_eq!(
+                        parameters[0],
+                        CallableParam::Single {
+                            name: Some("requestParameters".to_string()),
+                            type_name: TypeName::primitive(&request_interface_name(op)),
+                            presence: CallableParamPresence::Required,
+                        }
+                    );
+                }
+                other => panic!("uncovered fixture operation: {other}"),
+            }
+        }
+    }
+
+    #[test]
+    fn api_interface_renders_callable_properties_and_type_only_imports()
+    -> Result<(), SigilStitchError> {
+        let ir = api_interface_ir();
+        let ops = ["noInput", "cookieInput", "optionalInput", "submit"]
+            .iter()
+            .map(|id| {
+                ir.operations
+                    .iter()
+                    .find(|op| op.operation_id == *id)
+                    .expect("interface operation exists")
+            })
+            .collect::<Vec<_>>();
+        let interface = build_api_interface("EntriesApiInterface", &ops)?;
+        let fragments = interface.emit(&TypeScript::new())?;
+        let block = sigil_quote!(TypeScript { $C_each(fragments) })?;
+        assert_rendered!(
+            TypeScript::new(),
+            width = 180,
+            block,
+            r#"import type { Entry } from '../models/Entry';
+import type { InitOverrideFunction } from '../runtime/runtime';
+
+export interface EntriesApiInterface {
+  noInputRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<NoInputRawResponse>;
+  noInput: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  cookieInputRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<CookieInputRawResponse>;
+  cookieInput: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  optionalInputRaw: (requestParameters: ApiOptionalInputRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<OptionalInputRawResponse>;
+  optionalInput: (requestParameters: ApiOptionalInputRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Entry>;
+  submitRaw: (requestParameters: ApiSubmitRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SubmitRawResponse>;
+  submit: (requestParameters: ApiSubmitRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Entry>;
+}
+"#
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn api_interface_keeps_nested_return_types_structural_at_render_width()
+    -> Result<(), SigilStitchError> {
+        let ir = api_interface_ir();
+        let op = ir
+            .operations
+            .iter()
+            .find(|op| op.operation_id == "getEntries")
+            .expect("composite response operation exists");
+        let interface = build_api_interface("EntriesApiInterface", &[op])?;
+        let fragments = interface.emit(&TypeScript::new())?;
+        let block = sigil_quote!(TypeScript { $C_each(fragments) })?;
+        assert_rendered!(
+            TypeScript::new(),
+            width = 100,
+            block,
+            r#"import type { Entry } from '../models/Entry';
+import type { InitOverrideFunction } from '../runtime/runtime';
+
+export interface EntriesApiInterface {
+  getEntriesRaw: (requestParameters: ApiGetEntriesRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetEntriesRawResponse>;
+  getEntries: (requestParameters: ApiGetEntriesRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Entry[]
+  | string
+  | (string | null)[]>;
+}
+"#
+        );
+        Ok(())
+    }
+
     #[test]
     fn error_throw_composes_lazy_array_conversion_and_imports() -> Result<(), SigilStitchError> {
         let ir = response_dispatch_ir();
diff --git a/tests/fixtures/valid/typescript-api-interface.yaml b/tests/fixtures/valid/typescript-api-interface.yaml
new file mode 100644
index 00000000..c9a53762
--- /dev/null
+++ b/tests/fixtures/valid/typescript-api-interface.yaml
@@ -0,0 +1,101 @@
+openapi: 3.0.3
+info:
+  title: TypeScript API Interface
+  version: 1.0.0
+paths:
+  /no-input:
+    get:
+      tags: [Entries]
+      operationId: noInput
+      responses:
+        '204':
+          description: No payload.
+  /cookie-input:
+    get:
+      tags: [Entries]
+      operationId: cookieInput
+      parameters:
+        - name: session
+          in: cookie
+          required: true
+          schema:
+            type: string
+      responses:
+        '204':
+          description: Cookies do not add a request argument.
+  /optional-input:
+    get:
+      tags: [Entries]
+      operationId: optionalInput
+      parameters:
+        - name: filter
+          in: query
+          required: false
+          schema:
+            type: string
+      responses:
+        '200':
+          description: A typed payload.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Entry'
+  /submit:
+    post:
+      tags: [Entries]
+      operationId: submit
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/Entry'
+      responses:
+        '200':
+          description: The submitted payload.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Entry'
+  /entries/{id}:
+    get:
+      tags: [Entries]
+      operationId: getEntries
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Named array items.
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Entry'
+        '206':
+          description: A text alternative.
+          content:
+            text/plain:
+              schema:
+                type: string
+        '207':
+          description: Nullable array items retain their parentheses.
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string
+                  nullable: true
+components:
+  schemas:
+    Entry:
+      type: object
+      required: [display_name]
+      properties:
+        display_name:
+          type: string
diff --git a/tests/golden/typescript/typescript-fetch/additional-properties/apis/AdditionalPropertiesApi.ts.golden b/tests/golden/typescript/typescript-fetch/additional-properties/apis/AdditionalPropertiesApi.ts.golden
index 553f1121..84d970aa 100644
--- a/tests/golden/typescript/typescript-fetch/additional-properties/apis/AdditionalPropertiesApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/additional-properties/apis/AdditionalPropertiesApi.ts.golden
@@ -76,12 +76,18 @@ export class PostRootError extends ResponseError {
 
 
 export interface AdditionalPropertiesApiInterface {
-  postLeafRaw: (requestParameters: ApiPostLeafRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostLeafRawResponse>;
-  postLeaf: (requestParameters: ApiPostLeafRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<LeafValue>;
-  postMiddleRaw: (requestParameters: ApiPostMiddleRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostMiddleRawResponse>;
-  postMiddle: (requestParameters: ApiPostMiddleRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<MiddleLevel>;
-  postRootRaw: (requestParameters: ApiPostRootRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostRootRawResponse>;
-  postRoot: (requestParameters: ApiPostRootRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<RootLevel>;
+  postLeafRaw: (requestParameters: ApiPostLeafRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostLeafRawResponse>;
+  postLeaf: (requestParameters: ApiPostLeafRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<LeafValue>;
+  postMiddleRaw: (requestParameters: ApiPostMiddleRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostMiddleRawResponse>;
+  postMiddle: (requestParameters: ApiPostMiddleRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<MiddleLevel>;
+  postRootRaw: (requestParameters: ApiPostRootRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostRootRawResponse>;
+  postRoot: (requestParameters: ApiPostRootRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<RootLevel>;
 }
 
 export class AdditionalPropertiesApi extends BaseAPI implements AdditionalPropertiesApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/README.md.golden b/tests/golden/typescript/typescript-fetch/api-interface/README.md.golden
new file mode 100644
index 00000000..52271904
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/README.md.golden
@@ -0,0 +1,248 @@
+# type-script-api-interface
+
+Generated API client
+
+**Version:** 1.0.0
+
+## Overview
+
+This package provides a TypeScript/JavaScript client for the TypeScript API Interface API. It uses the native [Fetch API](https://fetch.spec.whatwg.org/) for HTTP requests and works in both Node.js and browser environments.
+
+## Features
+
+- ✨ **Type-safe** - Full TypeScript support with generated types
+- 🚀 **Modern** - Uses native Fetch API, no external HTTP dependencies
+- 🔧 **Configurable** - Flexible configuration options
+- 🎯 **Middleware** - Support for request/response interceptors
+- 📦 **Tree-shakeable** - Import only what you need
+- 🌐 **Universal** - Works in Node.js and browsers
+
+## Installation
+
+### From npm (published package)
+
+```bash
+npm install type-script-api-interface
+```
+
+### From local path (development)
+
+Add the package to your `package.json` using the `file:` protocol:
+
+```json
+{
+  "dependencies": {
+    "type-script-api-interface": "file:../../path/to/generated/package"
+  }
+}
+```
+
+Then run:
+
+```bash
+npm install
+```
+
+## Quick Start
+
+```typescript
+import { Configuration, EntriesApi } from 'type-script-api-interface';
+
+// Create a configuration
+const config = new Configuration({
+  basePath: 'https://api.example.com',
+  headers: {
+    'Authorization': 'Bearer YOUR_TOKEN'
+  }
+});
+
+// Initialize the API client
+const api = new EntriesApi(config);
+
+// Make API calls
+try {
+  const result = await api.someMethod();
+  console.log(result);
+} catch (error) {
+  console.error('API Error:', error);
+}
+```
+
+## Configuration
+
+The `Configuration` class accepts the following options:
+
+```typescript
+interface ConfigurationParameters {
+  /** Base URL for API requests */
+  basePath?: string;
+
+  /** Custom fetch implementation */
+  fetchApi?: typeof fetch;
+
+  /** Request/response middleware */
+  middleware?: Middleware[];
+
+  /** Custom query string serializer */
+  queryParamsStringify?: (params: HTTPQuery) => string;
+
+  /** Default headers for all requests */
+  headers?: Record<string, string>;
+
+  /** Credentials mode for requests */
+  credentials?: RequestCredentials;
+}
+```
+
+### Example with custom configuration
+
+```typescript
+const config = new Configuration({
+  basePath: 'https://api.example.com',
+  headers: {
+    'X-API-Key': 'your-api-key',
+    'Content-Type': 'application/json'
+  },
+  credentials: 'include'
+});
+```
+
+## Middleware
+
+Add custom middleware to intercept requests and responses:
+
+```typescript
+import { Configuration, Middleware } from 'type-script-api-interface';
+
+const loggingMiddleware: Middleware = {
+  pre: async (context) => {
+    console.log('Request:', context.url);
+    return context;
+  },
+  post: async (context) => {
+    console.log('Response:', context.response.status);
+    return context.response;
+  },
+  onError: async (context) => {
+    console.error('Error:', context.error);
+    return undefined;
+  }
+};
+
+const config = new Configuration({
+  basePath: 'https://api.example.com',
+  middleware: [loggingMiddleware]
+});
+```
+
+## Error Handling
+
+The client throws typed errors for different failure scenarios:
+
+```typescript
+import { ResponseError, FetchError, RequiredError } from 'type-script-api-interface';
+
+try {
+  const result = await api.someMethod();
+} catch (error) {
+  if (error instanceof ResponseError) {
+    // HTTP error response (4xx, 5xx)
+    console.error('HTTP Error:', error.response.status);
+  } else if (error instanceof FetchError) {
+    // Network or fetch error
+    console.error('Network Error:', error.cause);
+  } else if (error instanceof RequiredError) {
+    // Missing required parameter
+    console.error('Missing field:', error.field);
+  }
+}
+```
+
+## API Reference
+
+This package exports the following:
+
+- **Configuration** - Client configuration class
+- **BaseAPI** - Base class for all API clients
+- **API Classes** - Generated API client classes (e.g., `UserApi`, `PostApi`)
+- **Models** - Generated TypeScript interfaces for request/response types
+- **Errors** - `ResponseError`, `FetchError`, `RequiredError`
+- **Types** - TypeScript type definitions
+
+## Development
+
+### Building
+
+To build the package:
+
+```bash
+npm install
+npm run build
+```
+
+This will compile TypeScript to JavaScript in the `dist/` directory.
+
+### Building for ESM
+
+To build ES modules:
+
+```bash
+npm run build
+```
+
+## TypeScript Support
+
+This package includes TypeScript type definitions. No additional `@types` package is needed.
+
+### TypeScript Configuration
+
+This package works with standard TypeScript configurations. If you're using a bundler-based setup, you may want to configure:
+
+```json
+{
+  "compilerOptions": {
+    "moduleResolution": "bundler"
+  }
+}
+```
+
+### Type Imports
+
+```typescript
+import type { User, CreateUserRequest } from 'type-script-api-interface';
+
+const user: User = {
+  id: 1,
+  name: 'John Doe',
+  email: 'john@example.com'
+};
+```
+
+## Browser Support
+
+This package uses the native Fetch API, which is supported in:
+
+- Chrome 42+
+- Firefox 39+
+- Safari 10.1+
+- Edge 14+
+- Node.js 18+ (native fetch)
+- Node.js <18 (with `node-fetch` polyfill)
+
+For older browsers, you may need to include a fetch polyfill.
+
+## License
+
+This is an auto-generated API client. Please refer to your API documentation for license information.
+
+## Support
+
+For issues related to the API itself, please contact the API provider.
+
+For issues with this generated client, please check the OpenAPI specification used to generate it.
+
+---
+
+**Generated by OpenAPI Generator**
+
+API Version: 1.0.0
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/apis/EntriesApi.ts.golden b/tests/golden/typescript/typescript-fetch/api-interface/apis/EntriesApi.ts.golden
new file mode 100644
index 00000000..b30a691d
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/apis/EntriesApi.ts.golden
@@ -0,0 +1,360 @@
+/**
+ * @generated by openapi-nexus. Do not edit.
+ *
+ * TypeScript API Interface — 1.0.0
+ */
+import type { Entry } from '../models/Entry';
+import type { Configuration, HTTPQuery, HttpSuccessResponse, InitOverrideFunction } from '../runtime/runtime';
+import { BaseAPI, DefaultConfig, JSONApiResponse, RequiredError, ResponseError, TextApiResponse, VoidApiResponse } from '../runtime/runtime';
+
+export interface ApiCookieInputRequest {
+}
+
+export interface ApiGetEntriesRequest {
+  id: string;
+}
+
+export interface ApiOptionalInputRequest {
+  filter?: string;
+}
+
+export interface ApiSubmitRequest {
+  body?: Entry;
+}
+
+export type CookieInputRawResponse =
+  | VoidApiResponse & { status: 204 }
+  | VoidApiResponse & HttpSuccessResponse;
+
+export type GetEntriesRawResponse =
+  | JSONApiResponse<Entry[]> & { status: 200 }
+  | TextApiResponse & { status: 206 }
+  | JSONApiResponse<(string | null)[]> & { status: 207 }
+  | JSONApiResponse<unknown> & HttpSuccessResponse;
+
+export type NoInputRawResponse =
+  | VoidApiResponse & { status: 204 }
+  | VoidApiResponse & HttpSuccessResponse;
+
+export type OptionalInputRawResponse =
+  | JSONApiResponse<Entry> & { status: 200 }
+  | JSONApiResponse<unknown> & HttpSuccessResponse;
+
+export type SubmitRawResponse =
+  | JSONApiResponse<Entry> & { status: 200 }
+  | JSONApiResponse<unknown> & HttpSuccessResponse;
+
+
+export type CookieInputErrorDetail =
+  { kind: 'unexpected'; status: number; raw: Response; value(): Promise<Blob> };
+
+export class CookieInputError extends ResponseError {
+  readonly detail: CookieInputErrorDetail;
+
+  constructor(response: Response, detail: CookieInputErrorDetail, msg = 'Response returned an error code') {
+    super(response, msg);
+    this.detail = detail;
+  }
+}
+
+export type GetEntriesErrorDetail =
+  { kind: 'unexpected'; status: number; raw: Response; value(): Promise<Blob> };
+
+export class GetEntriesError extends ResponseError {
+  readonly detail: GetEntriesErrorDetail;
+
+  constructor(response: Response, detail: GetEntriesErrorDetail, msg = 'Response returned an error code') {
+    super(response, msg);
+    this.detail = detail;
+  }
+}
+
+export type NoInputErrorDetail =
+  { kind: 'unexpected'; status: number; raw: Response; value(): Promise<Blob> };
+
+export class NoInputError extends ResponseError {
+  readonly detail: NoInputErrorDetail;
+
+  constructor(response: Response, detail: NoInputErrorDetail, msg = 'Response returned an error code') {
+    super(response, msg);
+    this.detail = detail;
+  }
+}
+
+export type OptionalInputErrorDetail =
+  { kind: 'unexpected'; status: number; raw: Response; value(): Promise<Blob> };
+
+export class OptionalInputError extends ResponseError {
+  readonly detail: OptionalInputErrorDetail;
+
+  constructor(response: Response, detail: OptionalInputErrorDetail, msg = 'Response returned an error code') {
+    super(response, msg);
+    this.detail = detail;
+  }
+}
+
+export type SubmitErrorDetail =
+  { kind: 'unexpected'; status: number; raw: Response; value(): Promise<Blob> };
+
+export class SubmitError extends ResponseError {
+  readonly detail: SubmitErrorDetail;
+
+  constructor(response: Response, detail: SubmitErrorDetail, msg = 'Response returned an error code') {
+    super(response, msg);
+    this.detail = detail;
+  }
+}
+
+
+export interface EntriesApiInterface {
+  cookieInputRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CookieInputRawResponse>;
+  cookieInput: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  getEntriesRaw: (requestParameters: ApiGetEntriesRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetEntriesRawResponse>;
+  getEntries: (requestParameters: ApiGetEntriesRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Entry[]
+  | string
+  | (string | null)[]>;
+  noInputRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<NoInputRawResponse>;
+  noInput: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  optionalInputRaw: (requestParameters: ApiOptionalInputRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<OptionalInputRawResponse>;
+  optionalInput: (requestParameters: ApiOptionalInputRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Entry>;
+  submitRaw: (requestParameters: ApiSubmitRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SubmitRawResponse>;
+  submit: (requestParameters: ApiSubmitRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Entry>;
+}
+
+export class EntriesApi extends BaseAPI implements EntriesApiInterface {
+  /**
+   * Initialize the API client
+   */
+  constructor(configuration?: Configuration) {
+    super(configuration ?? DefaultConfig);
+  }
+
+  async cookieInputRaw(initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<CookieInputRawResponse> {
+    // Build path with path parameters
+    const urlPath = `/cookie-input`;
+    // Build query parameters
+    const queryParameters: HTTPQuery = {};
+    // Build headers
+    const headerParameters: Record<string, string> = {
+    };
+
+    // Make request
+    const response = await this.request({
+        path: urlPath,
+        method: 'GET',
+        headers: headerParameters,
+        query: queryParameters,
+        body: undefined,
+    }, initOverrides);
+
+    // Handle responses
+    if (!(response.status >= 200 && response.status < 300)) {
+      const errorRaw = response.clone();
+       {
+        let errorValue: Promise<Blob> | undefined;
+        throw new CookieInputError(response, { kind: 'unexpected', status: response.status, raw: response, value: () => errorValue ??= errorRaw.clone().blob() });
+      }
+    }
+    if (response.status === 204) {
+      return new VoidApiResponse(response) as VoidApiResponse & { status: 204 };
+    }
+    else {
+      return new VoidApiResponse(response) as VoidApiResponse & HttpSuccessResponse;
+    }
+  }
+
+  async cookieInput(initOverrides?: RequestInit | InitOverrideFunction): Promise<void> {
+    const response = await this.cookieInputRaw(initOverrides);
+    return await response.value();
+  }
+
+  async getEntriesRaw(requestParameters: ApiGetEntriesRequest, initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<GetEntriesRawResponse> {
+    if (requestParameters.id === undefined || requestParameters.id === null) {
+      throw new RequiredError(
+        'id',
+        'Required parameter "id" was null or undefined when calling getEntriesRaw().'
+      );
+    }
+    // Build path with path parameters
+    let urlPath = `/entries/{id}`;
+    urlPath = urlPath.replace(`{id}`, encodeURIComponent(String(requestParameters.id)));
+    // Build query parameters
+    const queryParameters: HTTPQuery = {};
+    // Build headers
+    const headerParameters: Record<string, string> = {
+    };
+
+    // Make request
+    const response = await this.request({
+        path: urlPath,
+        method: 'GET',
+        headers: headerParameters,
+        query: queryParameters,
+        body: undefined,
+    }, initOverrides);
+
+    // Handle responses
+    if (!(response.status >= 200 && response.status < 300)) {
+      const errorRaw = response.clone();
+       {
+        let errorValue: Promise<Blob> | undefined;
+        throw new GetEntriesError(response, { kind: 'unexpected', status: response.status, raw: response, value: () => errorValue ??= errorRaw.clone().blob() });
+      }
+    }
+    if (response.status === 200) {
+      return new JSONApiResponse(response) as JSONApiResponse<Entry[]> & { status: 200 };
+    }
+    else if (response.status === 206) {
+      return new TextApiResponse(response) as TextApiResponse & { status: 206 };
+    }
+    else if (response.status === 207) {
+      return new JSONApiResponse(response) as JSONApiResponse<(string | null)[]> & { status: 207 };
+    }
+    else {
+      return new JSONApiResponse(response) as JSONApiResponse<unknown> &HttpSuccessResponse;
+    }
+  }
+
+  async getEntries(requestParameters: ApiGetEntriesRequest, initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<Entry[] | string | (string | null)[]> {
+    const response = await this.getEntriesRaw(requestParameters, initOverrides);
+    return await response.value() as Entry[] | string | (string | null)[];
+  }
+
+  async noInputRaw(initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<NoInputRawResponse> {
+    // Build path with path parameters
+    const urlPath = `/no-input`;
+    // Build query parameters
+    const queryParameters: HTTPQuery = {};
+    // Build headers
+    const headerParameters: Record<string, string> = {
+    };
+
+    // Make request
+    const response = await this.request({
+        path: urlPath,
+        method: 'GET',
+        headers: headerParameters,
+        query: queryParameters,
+        body: undefined,
+    }, initOverrides);
+
+    // Handle responses
+    if (!(response.status >= 200 && response.status < 300)) {
+      const errorRaw = response.clone();
+       {
+        let errorValue: Promise<Blob> | undefined;
+        throw new NoInputError(response, { kind: 'unexpected', status: response.status, raw: response, value: () => errorValue ??= errorRaw.clone().blob() });
+      }
+    }
+    if (response.status === 204) {
+      return new VoidApiResponse(response) as VoidApiResponse & { status: 204 };
+    }
+    else {
+      return new VoidApiResponse(response) as VoidApiResponse & HttpSuccessResponse;
+    }
+  }
+
+  async noInput(initOverrides?: RequestInit | InitOverrideFunction): Promise<void> {
+    const response = await this.noInputRaw(initOverrides);
+    return await response.value();
+  }
+
+  async optionalInputRaw(requestParameters: ApiOptionalInputRequest, initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<OptionalInputRawResponse> {
+    // Build path with path parameters
+    const urlPath = `/optional-input`;
+    // Build query parameters
+    const queryParameters: HTTPQuery = {};
+    if (requestParameters.filter !== undefined) {
+      queryParameters['filter'] = requestParameters.filter;
+    }
+    // Build headers
+    const headerParameters: Record<string, string> = {
+    };
+
+    // Make request
+    const response = await this.request({
+        path: urlPath,
+        method: 'GET',
+        headers: headerParameters,
+        query: queryParameters,
+        body: undefined,
+    }, initOverrides);
+
+    // Handle responses
+    if (!(response.status >= 200 && response.status < 300)) {
+      const errorRaw = response.clone();
+       {
+        let errorValue: Promise<Blob> | undefined;
+        throw new OptionalInputError(response, { kind: 'unexpected', status: response.status, raw: response, value: () => errorValue ??= errorRaw.clone().blob() });
+      }
+    }
+    if (response.status === 200) {
+      return new JSONApiResponse(response) as JSONApiResponse<Entry> & { status: 200 };
+    }
+    else {
+      return new JSONApiResponse(response) as JSONApiResponse<unknown> &HttpSuccessResponse;
+    }
+  }
+
+  async optionalInput(requestParameters: ApiOptionalInputRequest, initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<Entry> {
+    const response = await this.optionalInputRaw(requestParameters, initOverrides);
+    return await response.value() as Entry;
+  }
+
+  async submitRaw(requestParameters: ApiSubmitRequest, initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<SubmitRawResponse> {
+    // Build path with path parameters
+    const urlPath = `/submit`;
+    // Build query parameters
+    const queryParameters: HTTPQuery = {};
+    // Build headers
+    const headerParameters: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    // Prepare request body
+    const requestBody = requestParameters.body;
+    // Make request
+    const response = await this.request({
+        path: urlPath,
+        method: 'POST',
+        headers: headerParameters,
+        query: queryParameters,
+        body: requestBody,
+    }, initOverrides);
+
+    // Handle responses
+    if (!(response.status >= 200 && response.status < 300)) {
+      const errorRaw = response.clone();
+       {
+        let errorValue: Promise<Blob> | undefined;
+        throw new SubmitError(response, { kind: 'unexpected', status: response.status, raw: response, value: () => errorValue ??= errorRaw.clone().blob() });
+      }
+    }
+    if (response.status === 200) {
+      return new JSONApiResponse(response) as JSONApiResponse<Entry> & { status: 200 };
+    }
+    else {
+      return new JSONApiResponse(response) as JSONApiResponse<unknown> &HttpSuccessResponse;
+    }
+  }
+
+  async submit(requestParameters: ApiSubmitRequest, initOverrides?: RequestInit
+    | InitOverrideFunction): Promise<Entry> {
+    const response = await this.submitRaw(requestParameters, initOverrides);
+    return await response.value() as Entry;
+  }
+}
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/apis/index.ts.golden b/tests/golden/typescript/typescript-fetch/api-interface/apis/index.ts.golden
new file mode 100644
index 00000000..8e379bb7
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/apis/index.ts.golden
@@ -0,0 +1,30 @@
+/**
+ * @generated by openapi-nexus. Do not edit.
+ *
+ * TypeScript API Interface — 1.0.0
+ */
+export type {
+  ApiCookieInputRequest,
+  CookieInputRawResponse,
+  CookieInputErrorDetail,
+  ApiGetEntriesRequest,
+  GetEntriesRawResponse,
+  GetEntriesErrorDetail,
+  NoInputRawResponse,
+  NoInputErrorDetail,
+  ApiOptionalInputRequest,
+  OptionalInputRawResponse,
+  OptionalInputErrorDetail,
+  ApiSubmitRequest,
+  SubmitRawResponse,
+  SubmitErrorDetail,
+  EntriesApiInterface,
+} from './EntriesApi';
+export {
+  EntriesApi,
+  CookieInputError,
+  GetEntriesError,
+  NoInputError,
+  OptionalInputError,
+  SubmitError,
+} from './EntriesApi';
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/index.ts.golden b/tests/golden/typescript/typescript-fetch/api-interface/index.ts.golden
new file mode 100644
index 00000000..39e4fffb
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/index.ts.golden
@@ -0,0 +1,8 @@
+/**
+ * @generated by openapi-nexus. Do not edit.
+ *
+ * TypeScript API Interface — 1.0.0
+ */
+export * from './runtime/runtime';
+export * from './apis';
+export * from './models';
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/models/Entry.ts.golden b/tests/golden/typescript/typescript-fetch/api-interface/models/Entry.ts.golden
new file mode 100644
index 00000000..87d8c087
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/models/Entry.ts.golden
@@ -0,0 +1,8 @@
+/**
+ * @generated by openapi-nexus. Do not edit.
+ *
+ * TypeScript API Interface — 1.0.0
+ */
+export interface Entry {
+  readonly display_name: string;
+}
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/models/index.ts.golden b/tests/golden/typescript/typescript-fetch/api-interface/models/index.ts.golden
new file mode 100644
index 00000000..e4cb0c85
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/models/index.ts.golden
@@ -0,0 +1,6 @@
+/**
+ * @generated by openapi-nexus. Do not edit.
+ *
+ * TypeScript API Interface — 1.0.0
+ */
+export type { Entry } from './Entry';
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/package.json.golden b/tests/golden/typescript/typescript-fetch/api-interface/package.json.golden
new file mode 100644
index 00000000..5761c8dc
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/package.json.golden
@@ -0,0 +1,26 @@
+{
+  "description": "TypeScript client for TypeScript API Interface",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "openapi",
+    "api-client",
+    "typescript",
+    "generated"
+  ],
+  "main": "./dist/index.js",
+  "name": "type-script-api-interface",
+  "scripts": {
+    "build": "tsc"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "1.0.0"
+}
\ No newline at end of file
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/runtime/runtime.ts.golden b/tests/golden/typescript/typescript-fetch/api-interface/runtime/runtime.ts.golden
new file mode 100644
index 00000000..55bc288f
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/runtime/runtime.ts.golden
@@ -0,0 +1,490 @@
+/**
+ * @generated by openapi-nexus. Do not edit.
+ *
+ * TypeScript API Interface — 1.0.0
+ */
+export const BASE_PATH = "http://localhost".replace(/\/+$/, "");
+
+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 | (() => string | Promise<string>); // parameter for basic security
+  password?: string | (() => string | Promise<string>); // parameter for basic security
+  apiKey?: string | Promise<string> | ((name: string) => string | Promise<string>); // parameter for apiKey security
+  accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<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 {
+  private configuration: ConfigurationParameters;
+
+  constructor(configuration: ConfigurationParameters = {}) {
+    this.configuration = configuration;
+  }
+
+  set config(configuration: ConfigurationParameters) {
+    this.configuration = configuration;
+  }
+
+  get basePath(): string {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+
+  get fetchApi(): FetchAPI | undefined {
+    return this.configuration.fetchApi;
+  }
+
+  get middleware(): Middleware[] {
+    return this.configuration.middleware || [];
+  }
+
+  get queryParamsStringify(): (params: HTTPQuery) => string {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+
+  get username(): (() => string | Promise<string>) | undefined {
+    const username = this.configuration.username;
+    if (username) {
+      return typeof username === 'function' ? username : async () => username;
+    }
+    return undefined;
+  }
+
+  get password(): (() => string | Promise<string>) | undefined {
+    const password = this.configuration.password;
+    if (password) {
+      return typeof password === 'function' ? password : async () => password;
+    }
+    return undefined;
+  }
+
+  get apiKey(): ((name: string) => string | Promise<string>) | undefined {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === 'function' ? apiKey : () => apiKey;
+    }
+    return undefined;
+  }
+
+  get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === 'function' ? accessToken : async () => accessToken;
+    }
+    return undefined;
+  }
+
+  get headers(): HTTPHeaders | undefined {
+    return this.configuration.headers;
+  }
+
+  get credentials(): RequestCredentials | undefined {
+    return this.configuration.credentials;
+  }
+}
+
+export const DefaultConfig = new Configuration();
+
+/**
+ * This is the base class for all generated API classes.
+ */
+export class BaseAPI {
+
+  private static readonly jsonRegex = new RegExp('^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
+  protected configuration: Configuration;
+  private middleware: Middleware[];
+
+  constructor(configuration: Configuration = DefaultConfig) {
+    this.configuration = 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);
+  }
+
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  protected isJsonMime(mime: string | null | undefined): boolean {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+
+  protected async request(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction): Promise<Response> {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    return await this.fetchApi(url, init);
+  }
+
+  private async createFetchParams(context: RequestOpts, initOverrides?: RequestInit | InitOverrideFunction) {
+    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 headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach(key => headers[key] === undefined ? delete headers[key] : {});
+
+    const token = await this.configuration.accessToken?.();
+    if (token) {
+      headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    if (!headers['Authorization']) {
+      const username = await this.configuration.username?.();
+      const password = await this.configuration.password?.();
+      if (username && password) {
+        headers['Authorization'] = `Basic ${btoa(`${username}:${password}`)}`;
+      }
+    }
+
+    const initOverrideFn =
+      typeof initOverrides === "function"
+        ? initOverrides
+        : async () => initOverrides;
+
+    const initParams: HTTPRequestInit = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials,
+      signal: context.signal,
+    };
+
+    const overriddenInit = {
+      ...initParams,
+      ...(await initOverrideFn({
+        init: initParams,
+        context,
+      }))
+    };
+
+    let body: BodyInit | null | undefined;
+    if (isFormData(overriddenInit.body)
+      || (overriddenInit.body instanceof URLSearchParams)
+      || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers['Content-Type'])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body as BodyInit | null | undefined;
+    }
+
+    const init: RequestInit = {
+      ...overriddenInit,
+      body
+    };
+
+    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: Response | undefined = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined,
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.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 new (configuration: Configuration) => T;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+
+function isBlob(value: unknown): value is Blob {
+  return typeof Blob !== 'undefined' && value instanceof Blob;
+}
+
+function isFormData(value: unknown): value is FormData {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+export class ResponseError extends Error {
+  override name = "ResponseError" as const;
+  public response: Response;
+
+  constructor(response: Response, msg?: string) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+export class FetchError extends Error {
+  override name = "FetchError" as const;
+  public cause: Error;
+
+  constructor(cause: Error, msg?: string) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+
+export class RequiredError extends Error {
+  override name = "RequiredError" as const;
+  public field: string;
+
+  constructor(field: string, msg?: string) {
+    super(msg);
+    this.field = field;
+  }
+}
+
+export type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
+
+export type Json = unknown;
+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> | Set<string | number | null | boolean> | HTTPQuery };
+export type HTTPBody = Json | Blob | FormData | URLSearchParams; // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
+export type HTTPRequestInit = { headers?: HTTPHeaders; method: HTTPMethod; credentials?: RequestCredentials; body?: HTTPBody; signal?: AbortSignal };
+export type ModelPropertyNaming = 'camelCase' | 'snake_case' | 'PascalCase' | 'original';
+
+export type InitOverrideFunction = (requestContext: { init: HTTPRequestInit, context: RequestOpts }) => Promise<RequestInit>
+
+export interface FetchParams {
+  url: string;
+  init: RequestInit;
+}
+
+export interface RequestOpts {
+  path: string;
+  method: HTTPMethod;
+  headers: HTTPHeaders;
+  query?: HTTPQuery;
+  body?: HTTPBody;
+  signal?: AbortSignal;
+}
+
+export function querystring(params: HTTPQuery, prefix: string = ''): string {
+  return Object.keys(params)
+    .map(key => querystringSingleKey(key, params[key], prefix))
+    .filter(part => part.length > 0)
+    .join('&');
+}
+
+function querystringSingleKey(key: string, value: string | number | null | undefined | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery, keyPrefix: string = ''): string {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
+      .join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value as HTTPQuery, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+
+export function exists(json: Record<string, unknown>, key: string): boolean {
+  const value = json[key];
+  return value !== null && value !== undefined;
+}
+
+export function mapValues<T, U>(data: Record<string, T>, fn: (item: T) => U): Record<string, U> {
+  const result: Record<string, U> = {};
+  for (const key of Object.keys(data)) {
+    result[key] = fn(data[key]);
+  }
+  return result;
+}
+
+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 ErrorContext {
+  fetch: FetchAPI;
+  url: string;
+  init: RequestInit;
+  error: unknown;
+  response?: Response;
+}
+
+export interface Middleware {
+  pre?(context: RequestContext): Promise<FetchParams | void>;
+  post?(context: ResponseContext): Promise<Response | void>;
+  onError?(context: ErrorContext): Promise<Response | void>;
+}
+
+export interface ApiResponse<T> {
+  raw: Response;
+  value(): Promise<T>;
+}
+
+export type HttpSuccessStatus =
+  | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209
+  | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219
+  | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229
+  | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239
+  | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249
+  | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259
+  | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269
+  | 270 | 271 | 272 | 273 | 274 | 275 | 276 | 277 | 278 | 279
+  | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289
+  | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299;
+
+export type HttpSuccessResponse = { status: HttpSuccessStatus };
+
+export interface ResponseTransformer<T> {
+  (json: unknown): T;
+}
+
+class ApiResponseBase {
+  public readonly status: number;
+  public readonly ok: boolean;
+  public readonly statusText: string;
+  public readonly headers: Headers;
+  public readonly raw: Response;
+
+  constructor(raw: Response) {
+    this.raw = raw;
+    this.status = raw.status;
+    this.ok = raw.ok;
+    this.statusText = raw.statusText;
+    this.headers = raw.headers;
+  }
+}
+
+export class JSONApiResponse<T> extends ApiResponseBase {
+  private transformer: ResponseTransformer<T>;
+
+  constructor(raw: Response, transformer: ResponseTransformer<T> = (jsonValue: unknown) => jsonValue as T) {
+    super(raw);
+    this.transformer = transformer;
+  }
+
+  async value(): Promise<T> {
+    return this.transformer(await this.raw.json());
+  }
+}
+
+export class VoidApiResponse extends ApiResponseBase {
+  constructor(raw: Response) {
+    super(raw);
+  }
+
+  async value(): Promise<void> {
+    return undefined;
+  }
+}
+
+export class BlobApiResponse extends ApiResponseBase {
+  constructor(raw: Response) {
+    super(raw);
+  }
+
+  async value(): Promise<Blob> {
+    return await this.raw.blob();
+  };
+}
+
+export class TextApiResponse extends ApiResponseBase {
+  constructor(raw: Response) {
+    super(raw);
+  }
+
+  async value(): Promise<string> {
+    return await this.raw.text();
+  };
+}
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/tsconfig.esm.json.golden b/tests/golden/typescript/typescript-fetch/api-interface/tsconfig.esm.json.golden
new file mode 100644
index 00000000..bb8350cb
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/tsconfig.esm.json.golden
@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "ES2020",
+    "outDir": "dist/esm"
+  },
+  "extends": "./tsconfig.json"
+}
\ No newline at end of file
diff --git a/tests/golden/typescript/typescript-fetch/api-interface/tsconfig.json.golden b/tests/golden/typescript/typescript-fetch/api-interface/tsconfig.json.golden
new file mode 100644
index 00000000..4b3a8cf7
--- /dev/null
+++ b/tests/golden/typescript/typescript-fetch/api-interface/tsconfig.json.golden
@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": [
+      "ES2020",
+      "DOM"
+    ],
+    "module": "ES2020",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "resolveJsonModule": true,
+    "rootDir": "./",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "ES2020",
+    "typeRoots": [
+      "node_modules/@types"
+    ]
+  },
+  "exclude": [
+    "dist",
+    "node_modules"
+  ],
+  "include": [
+    "**/*.ts"
+  ]
+}
\ No newline at end of file
diff --git a/tests/golden/typescript/typescript-fetch/binary-transfer-media-types/apis/TransferApi.ts.golden b/tests/golden/typescript/typescript-fetch/binary-transfer-media-types/apis/TransferApi.ts.golden
index a5d5158e..1af9bcf1 100644
--- a/tests/golden/typescript/typescript-fetch/binary-transfer-media-types/apis/TransferApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/binary-transfer-media-types/apis/TransferApi.ts.golden
@@ -54,10 +54,14 @@ export class UploadAssetError extends ResponseError {
 
 
 export interface TransferApiInterface {
-  downloadAssetRaw: (requestParameters: ApiDownloadAssetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DownloadAssetRawResponse>;
-  downloadAsset: (requestParameters: ApiDownloadAssetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Blob>;
-  uploadAssetRaw: (requestParameters: ApiUploadAssetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadAssetRawResponse>;
-  uploadAsset: (requestParameters: ApiUploadAssetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadMetadata>;
+  downloadAssetRaw: (requestParameters: ApiDownloadAssetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DownloadAssetRawResponse>;
+  downloadAsset: (requestParameters: ApiDownloadAssetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Blob>;
+  uploadAssetRaw: (requestParameters: ApiUploadAssetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadAssetRawResponse>;
+  uploadAsset: (requestParameters: ApiUploadAssetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadMetadata>;
 }
 
 export class TransferApi extends BaseAPI implements TransferApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/delete-with-response-schema/apis/TestResourceApi.ts.golden b/tests/golden/typescript/typescript-fetch/delete-with-response-schema/apis/TestResourceApi.ts.golden
index cb168490..6804fde0 100644
--- a/tests/golden/typescript/typescript-fetch/delete-with-response-schema/apis/TestResourceApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/delete-with-response-schema/apis/TestResourceApi.ts.golden
@@ -59,10 +59,14 @@ export class DeleteTestResourceError extends ResponseError {
 
 
 export interface TestResourceApiInterface {
-  createTestResourceRaw: (requestParameters: ApiCreateTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceRawResponse>;
-  createTestResource: (requestParameters: ApiCreateTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceResponse>;
-  deleteTestResourceRaw: (requestParameters: ApiDeleteTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceRawResponse>;
-  deleteTestResource: (requestParameters: ApiDeleteTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceResponse>;
+  createTestResourceRaw: (requestParameters: ApiCreateTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceRawResponse>;
+  createTestResource: (requestParameters: ApiCreateTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceResponse>;
+  deleteTestResourceRaw: (requestParameters: ApiDeleteTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceRawResponse>;
+  deleteTestResource: (requestParameters: ApiDeleteTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceResponse>;
 }
 
 export class TestResourceApi extends BaseAPI implements TestResourceApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/ItemsApi.ts.golden b/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/ItemsApi.ts.golden
index d1d5426a..9cefef07 100644
--- a/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/ItemsApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/ItemsApi.ts.golden
@@ -41,8 +41,12 @@ export class CreateItemWithBodyConflictError extends ResponseError {
 
 
 export interface ItemsApiInterface {
-  createItemWithBodyConflictRaw: (requestParameters: ApiCreateItemWithBodyConflictRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateItemWithBodyConflictRawResponse>;
-  createItemWithBodyConflict: (requestParameters: ApiCreateItemWithBodyConflictRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateItemWithBodyConflictResponse200>;
+  createItemWithBodyConflictRaw: (requestParameters: ApiCreateItemWithBodyConflictRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CreateItemWithBodyConflictRawResponse>;
+  createItemWithBodyConflict: (requestParameters: ApiCreateItemWithBodyConflictRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CreateItemWithBodyConflictResponse200>;
 }
 
 export class ItemsApi extends BaseAPI implements ItemsApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/UsersApi.ts.golden b/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/UsersApi.ts.golden
index 62c13eaf..290f5863 100644
--- a/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/UsersApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/duplicate-param-names/apis/UsersApi.ts.golden
@@ -44,8 +44,10 @@ export class GetUserByIdDuplicateError extends ResponseError {
 
 
 export interface UsersApiInterface {
-  getUserByIdDuplicateRaw: (requestParameters: ApiGetUserByIdDuplicateRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdDuplicateRawResponse>;
-  getUserByIdDuplicate: (requestParameters: ApiGetUserByIdDuplicateRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdDuplicateResponse200>;
+  getUserByIdDuplicateRaw: (requestParameters: ApiGetUserByIdDuplicateRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdDuplicateRawResponse>;
+  getUserByIdDuplicate: (requestParameters: ApiGetUserByIdDuplicateRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdDuplicateResponse200>;
 }
 
 export class UsersApi extends BaseAPI implements UsersApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/enum-repr/apis/EnumReprApi.ts.golden b/tests/golden/typescript/typescript-fetch/enum-repr/apis/EnumReprApi.ts.golden
index 68694281..01261dae 100644
--- a/tests/golden/typescript/typescript-fetch/enum-repr/apis/EnumReprApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/enum-repr/apis/EnumReprApi.ts.golden
@@ -120,16 +120,26 @@ export class HandleUntaggedError extends ResponseError {
 
 
 export interface EnumReprApiInterface {
-  handleAdjacentlyTaggedRaw: (requestParameters: ApiHandleAdjacentlyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleAdjacentlyTaggedRawResponse>;
-  handleAdjacentlyTagged: (requestParameters: ApiHandleAdjacentlyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<AdjacentlyTaggedEnum>;
-  handleExternallyTaggedRaw: (requestParameters: ApiHandleExternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleExternallyTaggedRawResponse>;
-  handleExternallyTagged: (requestParameters: ApiHandleExternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ExternallyTaggedEnum>;
-  handleInternallyTaggedRaw: (requestParameters: ApiHandleInternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleInternallyTaggedRawResponse>;
-  handleInternallyTagged: (requestParameters: ApiHandleInternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<InternallyTaggedEnum>;
-  handleMixedRaw: (requestParameters: ApiHandleMixedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleMixedRawResponse>;
-  handleMixed: (requestParameters: ApiHandleMixedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<MixedEnum>;
-  handleUntaggedRaw: (requestParameters: ApiHandleUntaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleUntaggedRawResponse>;
-  handleUntagged: (requestParameters: ApiHandleUntaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UntaggedEnum>;
+  handleAdjacentlyTaggedRaw: (requestParameters: ApiHandleAdjacentlyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleAdjacentlyTaggedRawResponse>;
+  handleAdjacentlyTagged: (requestParameters: ApiHandleAdjacentlyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<AdjacentlyTaggedEnum>;
+  handleExternallyTaggedRaw: (requestParameters: ApiHandleExternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleExternallyTaggedRawResponse>;
+  handleExternallyTagged: (requestParameters: ApiHandleExternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ExternallyTaggedEnum>;
+  handleInternallyTaggedRaw: (requestParameters: ApiHandleInternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleInternallyTaggedRawResponse>;
+  handleInternallyTagged: (requestParameters: ApiHandleInternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<InternallyTaggedEnum>;
+  handleMixedRaw: (requestParameters: ApiHandleMixedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleMixedRawResponse>;
+  handleMixed: (requestParameters: ApiHandleMixedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<MixedEnum>;
+  handleUntaggedRaw: (requestParameters: ApiHandleUntaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleUntaggedRawResponse>;
+  handleUntagged: (requestParameters: ApiHandleUntaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UntaggedEnum>;
 }
 
 export class EnumReprApi extends BaseAPI implements EnumReprApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/media-type-selection/apis/MediaApi.ts.golden b/tests/golden/typescript/typescript-fetch/media-type-selection/apis/MediaApi.ts.golden
index 3711b532..8a0d0daa 100644
--- a/tests/golden/typescript/typescript-fetch/media-type-selection/apis/MediaApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/media-type-selection/apis/MediaApi.ts.golden
@@ -120,17 +120,27 @@ export class GetVendorJsonError extends ResponseError {
 
 
 export interface MediaApiInterface {
-  sendJsonPreferredRaw: (requestParameters: ApiSendJsonPreferredRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendJsonPreferredRawResponse>;
-  sendJsonPreferred: (requestParameters: ApiSendJsonPreferredRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  sendParameterizedMultipartRaw: (requestParameters: ApiSendParameterizedMultipartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendParameterizedMultipartRawResponse>;
-  sendParameterizedMultipart: (requestParameters: ApiSendParameterizedMultipartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  sendVendorJsonRaw: (requestParameters: ApiSendVendorJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendVendorJsonRawResponse>;
-  sendVendorJson: (requestParameters: ApiSendVendorJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  getOctetPreferredRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetOctetPreferredRawResponse>;
+  sendJsonPreferredRaw: (requestParameters: ApiSendJsonPreferredRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendJsonPreferredRawResponse>;
+  sendJsonPreferred: (requestParameters: ApiSendJsonPreferredRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendParameterizedMultipartRaw: (requestParameters: ApiSendParameterizedMultipartRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<SendParameterizedMultipartRawResponse>;
+  sendParameterizedMultipart: (requestParameters: ApiSendParameterizedMultipartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendVendorJsonRaw: (requestParameters: ApiSendVendorJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendVendorJsonRawResponse>;
+  sendVendorJson: (requestParameters: ApiSendVendorJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  getOctetPreferredRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetOctetPreferredRawResponse>;
   getOctetPreferred: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Blob>;
-  getTextPreferredRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetTextPreferredRawResponse>;
+  getTextPreferredRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetTextPreferredRawResponse>;
   getTextPreferred: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<string>;
-  getVendorJsonRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetVendorJsonRawResponse>;
+  getVendorJsonRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetVendorJsonRawResponse>;
   getVendorJson: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Payload>;
 }
 
diff --git a/tests/golden/typescript/typescript-fetch/multipart-edge-cases/apis/MultipartApi.ts.golden b/tests/golden/typescript/typescript-fetch/multipart-edge-cases/apis/MultipartApi.ts.golden
index 9b3ea88d..050373ba 100644
--- a/tests/golden/typescript/typescript-fetch/multipart-edge-cases/apis/MultipartApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/multipart-edge-cases/apis/MultipartApi.ts.golden
@@ -52,10 +52,14 @@ export class SendTextFieldsError extends ResponseError {
 
 
 export interface MultipartApiInterface {
-  sendOptionalPartsRaw: (requestParameters: ApiSendOptionalPartsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalPartsRawResponse>;
-  sendOptionalParts: (requestParameters: ApiSendOptionalPartsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  sendTextFieldsRaw: (requestParameters: ApiSendTextFieldsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendTextFieldsRawResponse>;
-  sendTextFields: (requestParameters: ApiSendTextFieldsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendOptionalPartsRaw: (requestParameters: ApiSendOptionalPartsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalPartsRawResponse>;
+  sendOptionalParts: (requestParameters: ApiSendOptionalPartsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendTextFieldsRaw: (requestParameters: ApiSendTextFieldsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendTextFieldsRawResponse>;
+  sendTextFields: (requestParameters: ApiSendTextFieldsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class MultipartApi extends BaseAPI implements MultipartApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/multipart-explicit-encoding/apis/TransferApi.ts.golden b/tests/golden/typescript/typescript-fetch/multipart-explicit-encoding/apis/TransferApi.ts.golden
index e6807e88..6bd43d51 100644
--- a/tests/golden/typescript/typescript-fetch/multipart-explicit-encoding/apis/TransferApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/multipart-explicit-encoding/apis/TransferApi.ts.golden
@@ -31,8 +31,10 @@ export class UploadEncodedAssetError extends ResponseError {
 
 
 export interface TransferApiInterface {
-  uploadEncodedAssetRaw: (requestParameters: ApiUploadEncodedAssetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadEncodedAssetRawResponse>;
-  uploadEncodedAsset: (requestParameters: ApiUploadEncodedAssetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  uploadEncodedAssetRaw: (requestParameters: ApiUploadEncodedAssetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadEncodedAssetRawResponse>;
+  uploadEncodedAsset: (requestParameters: ApiUploadEncodedAssetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class TransferApi extends BaseAPI implements TransferApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/multipart-nested-object-parts/apis/MultipartApi.ts.golden b/tests/golden/typescript/typescript-fetch/multipart-nested-object-parts/apis/MultipartApi.ts.golden
index 2b447bd7..2d482ebb 100644
--- a/tests/golden/typescript/typescript-fetch/multipart-nested-object-parts/apis/MultipartApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/multipart-nested-object-parts/apis/MultipartApi.ts.golden
@@ -31,8 +31,10 @@ export class SendNestedObjectPartError extends ResponseError {
 
 
 export interface MultipartApiInterface {
-  sendNestedObjectPartRaw: (requestParameters: ApiSendNestedObjectPartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendNestedObjectPartRawResponse>;
-  sendNestedObjectPart: (requestParameters: ApiSendNestedObjectPartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendNestedObjectPartRaw: (requestParameters: ApiSendNestedObjectPartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendNestedObjectPartRawResponse>;
+  sendNestedObjectPart: (requestParameters: ApiSendNestedObjectPartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class MultipartApi extends BaseAPI implements MultipartApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/multipart-unsupported-schema/apis/TransferApi.ts.golden b/tests/golden/typescript/typescript-fetch/multipart-unsupported-schema/apis/TransferApi.ts.golden
index 3bb6d9eb..d3228e5c 100644
--- a/tests/golden/typescript/typescript-fetch/multipart-unsupported-schema/apis/TransferApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/multipart-unsupported-schema/apis/TransferApi.ts.golden
@@ -30,8 +30,10 @@ export class UploadRawMultipartError extends ResponseError {
 
 
 export interface TransferApiInterface {
-  uploadRawMultipartRaw: (requestParameters: ApiUploadRawMultipartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadRawMultipartRawResponse>;
-  uploadRawMultipart: (requestParameters: ApiUploadRawMultipartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  uploadRawMultipartRaw: (requestParameters: ApiUploadRawMultipartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadRawMultipartRawResponse>;
+  uploadRawMultipart: (requestParameters: ApiUploadRawMultipartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class TransferApi extends BaseAPI implements TransferApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/multiple-similar-request-schemas/apis/TestApiApi.ts.golden b/tests/golden/typescript/typescript-fetch/multiple-similar-request-schemas/apis/TestApiApi.ts.golden
index 417f0c24..f56dcc88 100644
--- a/tests/golden/typescript/typescript-fetch/multiple-similar-request-schemas/apis/TestApiApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/multiple-similar-request-schemas/apis/TestApiApi.ts.golden
@@ -54,10 +54,14 @@ export class CreateTypeBError extends ResponseError {
 
 
 export interface TestApiApiInterface {
-  createTypeARaw: (requestParameters: ApiCreateTypeARequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTypeARawResponse>;
-  createTypeA: (requestParameters: ApiCreateTypeARequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ResourceTypeA>;
-  createTypeBRaw: (requestParameters: ApiCreateTypeBRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTypeBRawResponse>;
-  createTypeB: (requestParameters: ApiCreateTypeBRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ResourceTypeB>;
+  createTypeARaw: (requestParameters: ApiCreateTypeARequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTypeARawResponse>;
+  createTypeA: (requestParameters: ApiCreateTypeARequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ResourceTypeA>;
+  createTypeBRaw: (requestParameters: ApiCreateTypeBRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTypeBRawResponse>;
+  createTypeB: (requestParameters: ApiCreateTypeBRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ResourceTypeB>;
 }
 
 export class TestApiApi extends BaseAPI implements TestApiApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/naming-conventions/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/naming-conventions/apis/DefaultApi.ts.golden
index 8bf86fc9..99707443 100644
--- a/tests/golden/typescript/typescript-fetch/naming-conventions/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/naming-conventions/apis/DefaultApi.ts.golden
@@ -62,10 +62,14 @@ export class TestNamingConventionsError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  getWithQueryParamsRaw: (requestParameters: ApiGetWithQueryParamsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetWithQueryParamsRawResponse>;
-  getWithQueryParams: (requestParameters: ApiGetWithQueryParamsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  testNamingConventionsRaw: (requestParameters: ApiTestNamingConventionsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestNamingConventionsRawResponse>;
-  testNamingConventions: (requestParameters: ApiTestNamingConventionsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<NamingConventionTest>;
+  getWithQueryParamsRaw: (requestParameters: ApiGetWithQueryParamsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetWithQueryParamsRawResponse>;
+  getWithQueryParams: (requestParameters: ApiGetWithQueryParamsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  testNamingConventionsRaw: (requestParameters: ApiTestNamingConventionsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestNamingConventionsRawResponse>;
+  testNamingConventions: (requestParameters: ApiTestNamingConventionsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<NamingConventionTest>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/nested-nullable/apis/ValuesApi.ts.golden b/tests/golden/typescript/typescript-fetch/nested-nullable/apis/ValuesApi.ts.golden
index 5587ccac..35e0f721 100644
--- a/tests/golden/typescript/typescript-fetch/nested-nullable/apis/ValuesApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/nested-nullable/apis/ValuesApi.ts.golden
@@ -35,7 +35,8 @@ export class GetValuesError extends ResponseError {
 
 
 export interface ValuesApiInterface {
-  getValuesRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetValuesRawResponse>;
+  getValuesRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetValuesRawResponse>;
   getValues: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<NullablePayload>;
 }
 
diff --git a/tests/golden/typescript/typescript-fetch/optional-request-bodies/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/optional-request-bodies/apis/DefaultApi.ts.golden
index 7b3d07b8..a53e59c8 100644
--- a/tests/golden/typescript/typescript-fetch/optional-request-bodies/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/optional-request-bodies/apis/DefaultApi.ts.golden
@@ -91,14 +91,22 @@ export class SendRequiredJsonError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  sendOptionalBinaryRaw: (requestParameters: ApiSendOptionalBinaryRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalBinaryRawResponse>;
-  sendOptionalBinary: (requestParameters: ApiSendOptionalBinaryRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  sendOptionalJsonRaw: (requestParameters: ApiSendOptionalJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalJsonRawResponse>;
-  sendOptionalJson: (requestParameters: ApiSendOptionalJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  sendOptionalTextRaw: (requestParameters: ApiSendOptionalTextRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalTextRawResponse>;
-  sendOptionalText: (requestParameters: ApiSendOptionalTextRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  sendRequiredJsonRaw: (requestParameters: ApiSendRequiredJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendRequiredJsonRawResponse>;
-  sendRequiredJson: (requestParameters: ApiSendRequiredJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendOptionalBinaryRaw: (requestParameters: ApiSendOptionalBinaryRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalBinaryRawResponse>;
+  sendOptionalBinary: (requestParameters: ApiSendOptionalBinaryRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendOptionalJsonRaw: (requestParameters: ApiSendOptionalJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalJsonRawResponse>;
+  sendOptionalJson: (requestParameters: ApiSendOptionalJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendOptionalTextRaw: (requestParameters: ApiSendOptionalTextRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendOptionalTextRawResponse>;
+  sendOptionalText: (requestParameters: ApiSendOptionalTextRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendRequiredJsonRaw: (requestParameters: ApiSendRequiredJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendRequiredJsonRawResponse>;
+  sendRequiredJson: (requestParameters: ApiSendRequiredJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/petstore/apis/PetApi.ts.golden b/tests/golden/typescript/typescript-fetch/petstore/apis/PetApi.ts.golden
index 6ca0cbaf..c8553744 100644
--- a/tests/golden/typescript/typescript-fetch/petstore/apis/PetApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/petstore/apis/PetApi.ts.golden
@@ -213,22 +213,38 @@ export class UploadFileError extends ResponseError {
 
 
 export interface PetApiInterface {
-  updatePetRaw: (requestParameters: ApiUpdatePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetRawResponse>;
-  updatePet: (requestParameters: ApiUpdatePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  addPetRaw: (requestParameters: ApiAddPetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<AddPetRawResponse>;
-  addPet: (requestParameters: ApiAddPetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  findPetsByStatusRaw: (requestParameters: ApiFindPetsByStatusRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByStatusRawResponse>;
-  findPetsByStatus: (requestParameters: ApiFindPetsByStatusRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
-  findPetsByTagsRaw: (requestParameters: ApiFindPetsByTagsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByTagsRawResponse>;
-  findPetsByTags: (requestParameters: ApiFindPetsByTagsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
-  getPetByIdRaw: (requestParameters: ApiGetPetByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetPetByIdRawResponse>;
-  getPetById: (requestParameters: ApiGetPetByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  updatePetWithFormRaw: (requestParameters: ApiUpdatePetWithFormRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetWithFormRawResponse>;
-  updatePetWithForm: (requestParameters: ApiUpdatePetWithFormRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  deletePetRaw: (requestParameters: ApiDeletePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeletePetRawResponse>;
-  deletePet: (requestParameters: ApiDeletePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  uploadFileRaw: (requestParameters: ApiUploadFileRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadFileRawResponse>;
-  uploadFile: (requestParameters: ApiUploadFileRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadResponse>;
+  updatePetRaw: (requestParameters: ApiUpdatePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetRawResponse>;
+  updatePet: (requestParameters: ApiUpdatePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  addPetRaw: (requestParameters: ApiAddPetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<AddPetRawResponse>;
+  addPet: (requestParameters: ApiAddPetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  findPetsByStatusRaw: (requestParameters: ApiFindPetsByStatusRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByStatusRawResponse>;
+  findPetsByStatus: (requestParameters: ApiFindPetsByStatusRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
+  findPetsByTagsRaw: (requestParameters: ApiFindPetsByTagsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByTagsRawResponse>;
+  findPetsByTags: (requestParameters: ApiFindPetsByTagsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
+  getPetByIdRaw: (requestParameters: ApiGetPetByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetPetByIdRawResponse>;
+  getPetById: (requestParameters: ApiGetPetByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  updatePetWithFormRaw: (requestParameters: ApiUpdatePetWithFormRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetWithFormRawResponse>;
+  updatePetWithForm: (requestParameters: ApiUpdatePetWithFormRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  deletePetRaw: (requestParameters: ApiDeletePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeletePetRawResponse>;
+  deletePet: (requestParameters: ApiDeletePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  uploadFileRaw: (requestParameters: ApiUploadFileRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadFileRawResponse>;
+  uploadFile: (requestParameters: ApiUploadFileRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadResponse>;
 }
 
 export class PetApi extends BaseAPI implements PetApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/petstore/apis/StoreApi.ts.golden b/tests/golden/typescript/typescript-fetch/petstore/apis/StoreApi.ts.golden
index fab9712e..cadc0fe4 100644
--- a/tests/golden/typescript/typescript-fetch/petstore/apis/StoreApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/petstore/apis/StoreApi.ts.golden
@@ -98,15 +98,22 @@ export class DeleteOrderError extends ResponseError {
 
 
 export interface StoreApiInterface {
-  getInventoryRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetInventoryRawResponse>;
+  getInventoryRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetInventoryRawResponse>;
   getInventory: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Record<string,
-number>>;
-  placeOrderRaw: (requestParameters: ApiPlaceOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PlaceOrderRawResponse>;
-  placeOrder: (requestParameters: ApiPlaceOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
-  getOrderByIdRaw: (requestParameters: ApiGetOrderByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetOrderByIdRawResponse>;
-  getOrderById: (requestParameters: ApiGetOrderByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
-  deleteOrderRaw: (requestParameters: ApiDeleteOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteOrderRawResponse>;
-  deleteOrder: (requestParameters: ApiDeleteOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  number>>;
+  placeOrderRaw: (requestParameters: ApiPlaceOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PlaceOrderRawResponse>;
+  placeOrder: (requestParameters: ApiPlaceOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
+  getOrderByIdRaw: (requestParameters: ApiGetOrderByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetOrderByIdRawResponse>;
+  getOrderById: (requestParameters: ApiGetOrderByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
+  deleteOrderRaw: (requestParameters: ApiDeleteOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteOrderRawResponse>;
+  deleteOrder: (requestParameters: ApiDeleteOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class StoreApi extends BaseAPI implements StoreApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/petstore/apis/UserApi.ts.golden b/tests/golden/typescript/typescript-fetch/petstore/apis/UserApi.ts.golden
index c80c141c..f6422334 100644
--- a/tests/golden/typescript/typescript-fetch/petstore/apis/UserApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/petstore/apis/UserApi.ts.golden
@@ -171,20 +171,34 @@ export class DeleteUserError extends ResponseError {
 
 
 export interface UserApiInterface {
-  createUserRaw: (requestParameters: ApiCreateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateUserRawResponse>;
-  createUser: (requestParameters: ApiCreateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
-  createUsersWithListInputRaw: (requestParameters: ApiCreateUsersWithListInputRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateUsersWithListInputRawResponse>;
-  createUsersWithListInput: (requestParameters: ApiCreateUsersWithListInputRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
-  loginUserRaw: (requestParameters: ApiLoginUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<LoginUserRawResponse>;
-  loginUser: (requestParameters: ApiLoginUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  logoutUserRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<LogoutUserRawResponse>;
+  createUserRaw: (requestParameters: ApiCreateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateUserRawResponse>;
+  createUser: (requestParameters: ApiCreateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
+  createUsersWithListInputRaw: (requestParameters: ApiCreateUsersWithListInputRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CreateUsersWithListInputRawResponse>;
+  createUsersWithListInput: (requestParameters: ApiCreateUsersWithListInputRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
+  loginUserRaw: (requestParameters: ApiLoginUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<LoginUserRawResponse>;
+  loginUser: (requestParameters: ApiLoginUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  logoutUserRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<LogoutUserRawResponse>;
   logoutUser: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  getUserByNameRaw: (requestParameters: ApiGetUserByNameRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByNameRawResponse>;
-  getUserByName: (requestParameters: ApiGetUserByNameRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
-  updateUserRaw: (requestParameters: ApiUpdateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdateUserRawResponse>;
-  updateUser: (requestParameters: ApiUpdateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  deleteUserRaw: (requestParameters: ApiDeleteUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteUserRawResponse>;
-  deleteUser: (requestParameters: ApiDeleteUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  getUserByNameRaw: (requestParameters: ApiGetUserByNameRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByNameRawResponse>;
+  getUserByName: (requestParameters: ApiGetUserByNameRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
+  updateUserRaw: (requestParameters: ApiUpdateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdateUserRawResponse>;
+  updateUser: (requestParameters: ApiUpdateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  deleteUserRaw: (requestParameters: ApiDeleteUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteUserRawResponse>;
+  deleteUser: (requestParameters: ApiDeleteUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class UserApi extends BaseAPI implements UserApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/query-param-enum/apis/ItemsApi.ts.golden b/tests/golden/typescript/typescript-fetch/query-param-enum/apis/ItemsApi.ts.golden
index a86a35a1..13a5945a 100644
--- a/tests/golden/typescript/typescript-fetch/query-param-enum/apis/ItemsApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/query-param-enum/apis/ItemsApi.ts.golden
@@ -36,8 +36,10 @@ export class GetItemsError extends ResponseError {
 
 
 export interface ItemsApiInterface {
-  getItemsRaw: (requestParameters: ApiGetItemsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetItemsRawResponse>;
-  getItems: (requestParameters: ApiGetItemsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetItemsResponse200>;
+  getItemsRaw: (requestParameters: ApiGetItemsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetItemsRawResponse>;
+  getItems: (requestParameters: ApiGetItemsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetItemsResponse200>;
 }
 
 export class ItemsApi extends BaseAPI implements ItemsApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/request-body-content-types/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/request-body-content-types/apis/DefaultApi.ts.golden
index fff76bf0..e90312d9 100644
--- a/tests/golden/typescript/typescript-fetch/request-body-content-types/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/request-body-content-types/apis/DefaultApi.ts.golden
@@ -167,21 +167,36 @@ export class GetXmlResponseError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  postBinaryRaw: (requestParameters: ApiPostBinaryRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostBinaryRawResponse>;
-  postBinary: (requestParameters: ApiPostBinaryRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  postFormRaw: (requestParameters: ApiPostFormRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostFormRawResponse>;
-  postForm: (requestParameters: ApiPostFormRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  postJsonRaw: (requestParameters: ApiPostJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostJsonRawResponse>;
-  postJson: (requestParameters: ApiPostJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  postJsonOrXmlRaw: (requestParameters: ApiPostJsonOrXmlRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostJsonOrXmlRawResponse>;
-  postJsonOrXml: (requestParameters: ApiPostJsonOrXmlRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  patchMergeJsonRaw: (requestParameters: ApiPatchMergeJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PatchMergeJsonRawResponse>;
-  patchMergeJson: (requestParameters: ApiPatchMergeJsonRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  postTextRaw: (requestParameters: ApiPostTextRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostTextRawResponse>;
-  postText: (requestParameters: ApiPostTextRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  postXmlRaw: (requestParameters: ApiPostXmlRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostXmlRawResponse>;
-  postXml: (requestParameters: ApiPostXmlRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  getXmlResponseRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetXmlResponseRawResponse>;
+  postBinaryRaw: (requestParameters: ApiPostBinaryRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostBinaryRawResponse>;
+  postBinary: (requestParameters: ApiPostBinaryRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  postFormRaw: (requestParameters: ApiPostFormRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostFormRawResponse>;
+  postForm: (requestParameters: ApiPostFormRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  postJsonRaw: (requestParameters: ApiPostJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostJsonRawResponse>;
+  postJson: (requestParameters: ApiPostJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  postJsonOrXmlRaw: (requestParameters: ApiPostJsonOrXmlRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostJsonOrXmlRawResponse>;
+  postJsonOrXml: (requestParameters: ApiPostJsonOrXmlRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  patchMergeJsonRaw: (requestParameters: ApiPatchMergeJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PatchMergeJsonRawResponse>;
+  patchMergeJson: (requestParameters: ApiPatchMergeJsonRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  postTextRaw: (requestParameters: ApiPostTextRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostTextRawResponse>;
+  postText: (requestParameters: ApiPostTextRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  postXmlRaw: (requestParameters: ApiPostXmlRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PostXmlRawResponse>;
+  postXml: (requestParameters: ApiPostXmlRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  getXmlResponseRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetXmlResponseRawResponse>;
   getXmlResponse: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<string>;
 }
 
diff --git a/tests/golden/typescript/typescript-fetch/response-body-default-and-exact/apis/WidgetApi.ts.golden b/tests/golden/typescript/typescript-fetch/response-body-default-and-exact/apis/WidgetApi.ts.golden
index 6f85fa42..bb5ee300 100644
--- a/tests/golden/typescript/typescript-fetch/response-body-default-and-exact/apis/WidgetApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/response-body-default-and-exact/apis/WidgetApi.ts.golden
@@ -28,7 +28,8 @@ export class GetWidgetError extends ResponseError {
 
 
 export interface WidgetApiInterface {
-  getWidgetRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetWidgetRawResponse>;
+  getWidgetRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetWidgetRawResponse>;
   getWidget: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Widget>;
 }
 
diff --git a/tests/golden/typescript/typescript-fetch/response-body-fallback/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/response-body-fallback/apis/DefaultApi.ts.golden
index af3b72f3..4a77d4ff 100644
--- a/tests/golden/typescript/typescript-fetch/response-body-fallback/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/response-body-fallback/apis/DefaultApi.ts.golden
@@ -44,10 +44,13 @@ export class GetFallbackWithBodyError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  getFallbackNoBodyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetFallbackNoBodyRawResponse>;
+  getFallbackNoBodyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetFallbackNoBodyRawResponse>;
   getFallbackNoBody: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  getFallbackWithBodyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetFallbackWithBodyRawResponse>;
-  getFallbackWithBody: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetFallbackWithBodyResponse200>;
+  getFallbackWithBodyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetFallbackWithBodyRawResponse>;
+  getFallbackWithBody: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetFallbackWithBodyResponse200>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/response-body-multi-status-responses/apis/WidgetApi.ts.golden b/tests/golden/typescript/typescript-fetch/response-body-multi-status-responses/apis/WidgetApi.ts.golden
index a7220020..0b47e405 100644
--- a/tests/golden/typescript/typescript-fetch/response-body-multi-status-responses/apis/WidgetApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/response-body-multi-status-responses/apis/WidgetApi.ts.golden
@@ -30,9 +30,10 @@ export class ListWidgetsError extends ResponseError {
 
 
 export interface WidgetApiInterface {
-  listWidgetsRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ListWidgetsRawResponse>;
+  listWidgetsRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ListWidgetsRawResponse>;
   listWidgets: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Widget[]
-| WidgetListPartial>;
+  | WidgetListPartial>;
 }
 
 export class WidgetApi extends BaseAPI implements WidgetApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/response-body-no-response-body/apis/FooApi.ts.golden b/tests/golden/typescript/typescript-fetch/response-body-no-response-body/apis/FooApi.ts.golden
index 8dc2ce56..0829a569 100644
--- a/tests/golden/typescript/typescript-fetch/response-body-no-response-body/apis/FooApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/response-body-no-response-body/apis/FooApi.ts.golden
@@ -34,8 +34,10 @@ export class UpdateFooBarError extends ResponseError {
 
 
 export interface FooApiInterface {
-  updateFooBarRaw: (requestParameters: ApiUpdateFooBarRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdateFooBarRawResponse>;
-  updateFooBar: (requestParameters: ApiUpdateFooBarRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  updateFooBarRaw: (requestParameters: ApiUpdateFooBarRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdateFooBarRawResponse>;
+  updateFooBar: (requestParameters: ApiUpdateFooBarRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class FooApi extends BaseAPI implements FooApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/response-dispatch/apis/ResponsesApi.ts.golden b/tests/golden/typescript/typescript-fetch/response-dispatch/apis/ResponsesApi.ts.golden
index 175cf1ba..ec411211 100644
--- a/tests/golden/typescript/typescript-fetch/response-dispatch/apis/ResponsesApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/response-dispatch/apis/ResponsesApi.ts.golden
@@ -101,18 +101,23 @@ export class ReadWildcardsError extends ResponseError {
 
 
 export interface ResponsesApiInterface {
-  readDefaultRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadDefaultRawResponse>;
+  readDefaultRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadDefaultRawResponse>;
   readDefault: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  readErrorOnlyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadErrorOnlyRawResponse>;
+  readErrorOnlyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadErrorOnlyRawResponse>;
   readErrorOnly: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  readMixedRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadMixedRawResponse>;
+  readMixedRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadMixedRawResponse>;
   readMixed: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Detail
-| string
-| Blob
-| Detail[]>;
-  readSuccessOnlyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadSuccessOnlyRawResponse>;
+  | string
+  | Blob
+  | Detail[]>;
+  readSuccessOnlyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadSuccessOnlyRawResponse>;
   readSuccessOnly: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  readWildcardsRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadWildcardsRawResponse>;
+  readWildcardsRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadWildcardsRawResponse>;
   readWildcards: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
diff --git a/tests/golden/typescript/typescript-fetch/server-object/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/server-object/apis/DefaultApi.ts.golden
index 77b5dee1..19783a9c 100644
--- a/tests/golden/typescript/typescript-fetch/server-object/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/server-object/apis/DefaultApi.ts.golden
@@ -53,10 +53,14 @@ export class GetUserByIdError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  getAllUsersRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetAllUsersRawResponse>;
-  getAllUsers: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetAllUsersResponse200Item[]>;
-  getUserByIdRaw: (requestParameters: ApiGetUserByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdRawResponse>;
-  getUserById: (requestParameters: ApiGetUserByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdResponse200>;
+  getAllUsersRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetAllUsersRawResponse>;
+  getAllUsers: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetAllUsersResponse200Item[]>;
+  getUserByIdRaw: (requestParameters: ApiGetUserByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdRawResponse>;
+  getUserById: (requestParameters: ApiGetUserByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByIdResponse200>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/server-path-prefix/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/server-path-prefix/apis/DefaultApi.ts.golden
index 65be0389..59e434b7 100644
--- a/tests/golden/typescript/typescript-fetch/server-path-prefix/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/server-path-prefix/apis/DefaultApi.ts.golden
@@ -62,12 +62,16 @@ export class GetUserError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  healthCheckRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<HealthCheckRawResponse>;
+  healthCheckRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<HealthCheckRawResponse>;
   healthCheck: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  listUsersRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ListUsersRawResponse>;
+  listUsersRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ListUsersRawResponse>;
   listUsers: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  getUserRaw: (requestParameters: ApiGetUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserRawResponse>;
-  getUser: (requestParameters: ApiGetUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  getUserRaw: (requestParameters: ApiGetUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserRawResponse>;
+  getUser: (requestParameters: ApiGetUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-intersection/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-intersection/apis/DefaultApi.ts.golden
index 862dbf2e..ef3473f6 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-intersection/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-intersection/apis/DefaultApi.ts.golden
@@ -32,8 +32,10 @@ export class TestIntersectionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testIntersectionRaw: (requestParameters: ApiTestIntersectionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestIntersectionRawResponse>;
-  testIntersection: (requestParameters: ApiTestIntersectionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testIntersectionRaw: (requestParameters: ApiTestIntersectionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestIntersectionRawResponse>;
+  testIntersection: (requestParameters: ApiTestIntersectionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-multipart-parts/apis/MultipartApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-multipart-parts/apis/MultipartApi.ts.golden
index 3605ac10..bccb766f 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-multipart-parts/apis/MultipartApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-multipart-parts/apis/MultipartApi.ts.golden
@@ -32,8 +32,10 @@ export class SendNestedObjectPartError extends ResponseError {
 
 
 export interface MultipartApiInterface {
-  sendNestedObjectPartRaw: (requestParameters: ApiSendNestedObjectPartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendNestedObjectPartRawResponse>;
-  sendNestedObjectPart: (requestParameters: ApiSendNestedObjectPartRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  sendNestedObjectPartRaw: (requestParameters: ApiSendNestedObjectPartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<SendNestedObjectPartRawResponse>;
+  sendNestedObjectPart: (requestParameters: ApiSendNestedObjectPartRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class MultipartApi extends BaseAPI implements MultipartApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-dispatch/apis/ResponsesApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-dispatch/apis/ResponsesApi.ts.golden
index a2e7f711..b07f3532 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-dispatch/apis/ResponsesApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-dispatch/apis/ResponsesApi.ts.golden
@@ -102,18 +102,23 @@ export class ReadWildcardsError extends ResponseError {
 
 
 export interface ResponsesApiInterface {
-  readDefaultRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadDefaultRawResponse>;
+  readDefaultRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadDefaultRawResponse>;
   readDefault: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  readErrorOnlyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadErrorOnlyRawResponse>;
+  readErrorOnlyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadErrorOnlyRawResponse>;
   readErrorOnly: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  readMixedRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadMixedRawResponse>;
+  readMixedRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadMixedRawResponse>;
   readMixed: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Detail
-| string
-| Blob
-| Detail[]>;
-  readSuccessOnlyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadSuccessOnlyRawResponse>;
+  | string
+  | Blob
+  | Detail[]>;
+  readSuccessOnlyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadSuccessOnlyRawResponse>;
   readSuccessOnly: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  readWildcardsRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<ReadWildcardsRawResponse>;
+  readWildcardsRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<ReadWildcardsRawResponse>;
   readWildcards: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-only-types/apis/TestResourceApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-only-types/apis/TestResourceApi.ts.golden
index 02e26463..9c4b5aa4 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-only-types/apis/TestResourceApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-response-only-types/apis/TestResourceApi.ts.golden
@@ -62,10 +62,14 @@ export class DeleteTestResourceError extends ResponseError {
 
 
 export interface TestResourceApiInterface {
-  createTestResourceRaw: (requestParameters: ApiCreateTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceRawResponse>;
-  createTestResource: (requestParameters: ApiCreateTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceResponse>;
-  deleteTestResourceRaw: (requestParameters: ApiDeleteTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceRawResponse>;
-  deleteTestResource: (requestParameters: ApiDeleteTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceResponse>;
+  createTestResourceRaw: (requestParameters: ApiCreateTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceRawResponse>;
+  createTestResource: (requestParameters: ApiCreateTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceResponse>;
+  deleteTestResourceRaw: (requestParameters: ApiDeleteTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceRawResponse>;
+  deleteTestResource: (requestParameters: ApiDeleteTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceResponse>;
 }
 
 export class TestResourceApi extends BaseAPI implements TestResourceApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-plain-internal/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-plain-internal/apis/DefaultApi.ts.golden
index f9df690e..5fede101 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-plain-internal/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-plain-internal/apis/DefaultApi.ts.golden
@@ -33,8 +33,10 @@ export class PreviewError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  previewRaw: (requestParameters: ApiPreviewRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PreviewRawResponse>;
-  preview: (requestParameters: ApiPreviewRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PreviewRequest>;
+  previewRaw: (requestParameters: ApiPreviewRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PreviewRawResponse>;
+  preview: (requestParameters: ApiPreviewRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PreviewRequest>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-variant-with-discriminator/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-variant-with-discriminator/apis/DefaultApi.ts.golden
index 57d3893e..bef2df36 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-variant-with-discriminator/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union-variant-with-discriminator/apis/DefaultApi.ts.golden
@@ -35,8 +35,10 @@ export class CreateSetupError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createSetupRaw: (requestParameters: ApiCreateSetupRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateSetupRawResponse>;
-  createSetup: (requestParameters: ApiCreateSetupRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Setup>;
+  createSetupRaw: (requestParameters: ApiCreateSetupRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateSetupRawResponse>;
+  createSetup: (requestParameters: ApiCreateSetupRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Setup>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union/apis/DefaultApi.ts.golden
index 6900acc1..9971ee61 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-tagged-union/apis/DefaultApi.ts.golden
@@ -33,8 +33,10 @@ export class CreateContainerError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createContainerRaw: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
-  createContainer: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerImage>;
+  createContainerRaw: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
+  createContainer: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerImage>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-union/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-union/apis/DefaultApi.ts.golden
index d36f76be..a7144f69 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-union/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case-union/apis/DefaultApi.ts.golden
@@ -32,8 +32,10 @@ export class TestUnionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testUnionRaw: (requestParameters: ApiTestUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionRawResponse>;
-  testUnion: (requestParameters: ApiTestUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testUnionRaw: (requestParameters: ApiTestUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionRawResponse>;
+  testUnion: (requestParameters: ApiTestUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case/apis/DefaultApi.ts.golden
index a732bb95..6fc5cd4a 100644
--- a/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-property-naming-camel-case/apis/DefaultApi.ts.golden
@@ -63,10 +63,14 @@ export class TestNamingConventionsError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  getWithQueryParamsRaw: (requestParameters: ApiGetWithQueryParamsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetWithQueryParamsRawResponse>;
-  getWithQueryParams: (requestParameters: ApiGetWithQueryParamsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  testNamingConventionsRaw: (requestParameters: ApiTestNamingConventionsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestNamingConventionsRawResponse>;
-  testNamingConventions: (requestParameters: ApiTestNamingConventionsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<NamingConventionTest>;
+  getWithQueryParamsRaw: (requestParameters: ApiGetWithQueryParamsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetWithQueryParamsRawResponse>;
+  getWithQueryParams: (requestParameters: ApiGetWithQueryParamsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  testNamingConventionsRaw: (requestParameters: ApiTestNamingConventionsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestNamingConventionsRawResponse>;
+  testNamingConventions: (requestParameters: ApiTestNamingConventionsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<NamingConventionTest>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-camel-case-tagged-nullable-unions/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-camel-case-tagged-nullable-unions/apis/DefaultApi.ts.golden
index a7b07acd..e442da19 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-camel-case-tagged-nullable-unions/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-camel-case-tagged-nullable-unions/apis/DefaultApi.ts.golden
@@ -32,8 +32,10 @@ export class CreateFooEnvelopeError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createFooEnvelopeRaw: (requestParameters: ApiCreateFooEnvelopeRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateFooEnvelopeRawResponse>;
-  createFooEnvelope: (requestParameters: ApiCreateFooEnvelopeRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<FooEnvelope>;
+  createFooEnvelopeRaw: (requestParameters: ApiCreateFooEnvelopeRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateFooEnvelopeRawResponse>;
+  createFooEnvelope: (requestParameters: ApiCreateFooEnvelopeRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<FooEnvelope>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-delete-response/apis/TestResourceApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-delete-response/apis/TestResourceApi.ts.golden
index 02e26463..9c4b5aa4 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-delete-response/apis/TestResourceApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-delete-response/apis/TestResourceApi.ts.golden
@@ -62,10 +62,14 @@ export class DeleteTestResourceError extends ResponseError {
 
 
 export interface TestResourceApiInterface {
-  createTestResourceRaw: (requestParameters: ApiCreateTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceRawResponse>;
-  createTestResource: (requestParameters: ApiCreateTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceResponse>;
-  deleteTestResourceRaw: (requestParameters: ApiDeleteTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceRawResponse>;
-  deleteTestResource: (requestParameters: ApiDeleteTestResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceResponse>;
+  createTestResourceRaw: (requestParameters: ApiCreateTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceRawResponse>;
+  createTestResource: (requestParameters: ApiCreateTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestResourceResponse>;
+  deleteTestResourceRaw: (requestParameters: ApiDeleteTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceRawResponse>;
+  deleteTestResource: (requestParameters: ApiDeleteTestResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteTestResourceResponse>;
 }
 
 export class TestResourceApi extends BaseAPI implements TestResourceApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-enum-repr/apis/EnumReprApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-enum-repr/apis/EnumReprApi.ts.golden
index 68694281..01261dae 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-enum-repr/apis/EnumReprApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-enum-repr/apis/EnumReprApi.ts.golden
@@ -120,16 +120,26 @@ export class HandleUntaggedError extends ResponseError {
 
 
 export interface EnumReprApiInterface {
-  handleAdjacentlyTaggedRaw: (requestParameters: ApiHandleAdjacentlyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleAdjacentlyTaggedRawResponse>;
-  handleAdjacentlyTagged: (requestParameters: ApiHandleAdjacentlyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<AdjacentlyTaggedEnum>;
-  handleExternallyTaggedRaw: (requestParameters: ApiHandleExternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleExternallyTaggedRawResponse>;
-  handleExternallyTagged: (requestParameters: ApiHandleExternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ExternallyTaggedEnum>;
-  handleInternallyTaggedRaw: (requestParameters: ApiHandleInternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleInternallyTaggedRawResponse>;
-  handleInternallyTagged: (requestParameters: ApiHandleInternallyTaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<InternallyTaggedEnum>;
-  handleMixedRaw: (requestParameters: ApiHandleMixedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleMixedRawResponse>;
-  handleMixed: (requestParameters: ApiHandleMixedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<MixedEnum>;
-  handleUntaggedRaw: (requestParameters: ApiHandleUntaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleUntaggedRawResponse>;
-  handleUntagged: (requestParameters: ApiHandleUntaggedRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UntaggedEnum>;
+  handleAdjacentlyTaggedRaw: (requestParameters: ApiHandleAdjacentlyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleAdjacentlyTaggedRawResponse>;
+  handleAdjacentlyTagged: (requestParameters: ApiHandleAdjacentlyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<AdjacentlyTaggedEnum>;
+  handleExternallyTaggedRaw: (requestParameters: ApiHandleExternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleExternallyTaggedRawResponse>;
+  handleExternallyTagged: (requestParameters: ApiHandleExternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ExternallyTaggedEnum>;
+  handleInternallyTaggedRaw: (requestParameters: ApiHandleInternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleInternallyTaggedRawResponse>;
+  handleInternallyTagged: (requestParameters: ApiHandleInternallyTaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<InternallyTaggedEnum>;
+  handleMixedRaw: (requestParameters: ApiHandleMixedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleMixedRawResponse>;
+  handleMixed: (requestParameters: ApiHandleMixedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<MixedEnum>;
+  handleUntaggedRaw: (requestParameters: ApiHandleUntaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleUntaggedRawResponse>;
+  handleUntagged: (requestParameters: ApiHandleUntaggedRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UntaggedEnum>;
 }
 
 export class EnumReprApi extends BaseAPI implements EnumReprApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/PetApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/PetApi.ts.golden
index 6ca0cbaf..c8553744 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/PetApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/PetApi.ts.golden
@@ -213,22 +213,38 @@ export class UploadFileError extends ResponseError {
 
 
 export interface PetApiInterface {
-  updatePetRaw: (requestParameters: ApiUpdatePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetRawResponse>;
-  updatePet: (requestParameters: ApiUpdatePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  addPetRaw: (requestParameters: ApiAddPetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<AddPetRawResponse>;
-  addPet: (requestParameters: ApiAddPetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  findPetsByStatusRaw: (requestParameters: ApiFindPetsByStatusRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByStatusRawResponse>;
-  findPetsByStatus: (requestParameters: ApiFindPetsByStatusRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
-  findPetsByTagsRaw: (requestParameters: ApiFindPetsByTagsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByTagsRawResponse>;
-  findPetsByTags: (requestParameters: ApiFindPetsByTagsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
-  getPetByIdRaw: (requestParameters: ApiGetPetByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetPetByIdRawResponse>;
-  getPetById: (requestParameters: ApiGetPetByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  updatePetWithFormRaw: (requestParameters: ApiUpdatePetWithFormRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetWithFormRawResponse>;
-  updatePetWithForm: (requestParameters: ApiUpdatePetWithFormRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
-  deletePetRaw: (requestParameters: ApiDeletePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeletePetRawResponse>;
-  deletePet: (requestParameters: ApiDeletePetRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  uploadFileRaw: (requestParameters: ApiUploadFileRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadFileRawResponse>;
-  uploadFile: (requestParameters: ApiUploadFileRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadResponse>;
+  updatePetRaw: (requestParameters: ApiUpdatePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetRawResponse>;
+  updatePet: (requestParameters: ApiUpdatePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  addPetRaw: (requestParameters: ApiAddPetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<AddPetRawResponse>;
+  addPet: (requestParameters: ApiAddPetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  findPetsByStatusRaw: (requestParameters: ApiFindPetsByStatusRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByStatusRawResponse>;
+  findPetsByStatus: (requestParameters: ApiFindPetsByStatusRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
+  findPetsByTagsRaw: (requestParameters: ApiFindPetsByTagsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<FindPetsByTagsRawResponse>;
+  findPetsByTags: (requestParameters: ApiFindPetsByTagsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet[]>;
+  getPetByIdRaw: (requestParameters: ApiGetPetByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetPetByIdRawResponse>;
+  getPetById: (requestParameters: ApiGetPetByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  updatePetWithFormRaw: (requestParameters: ApiUpdatePetWithFormRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdatePetWithFormRawResponse>;
+  updatePetWithForm: (requestParameters: ApiUpdatePetWithFormRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Pet>;
+  deletePetRaw: (requestParameters: ApiDeletePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeletePetRawResponse>;
+  deletePet: (requestParameters: ApiDeletePetRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  uploadFileRaw: (requestParameters: ApiUploadFileRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadFileRawResponse>;
+  uploadFile: (requestParameters: ApiUploadFileRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UploadResponse>;
 }
 
 export class PetApi extends BaseAPI implements PetApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/StoreApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/StoreApi.ts.golden
index fab9712e..cadc0fe4 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/StoreApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/StoreApi.ts.golden
@@ -98,15 +98,22 @@ export class DeleteOrderError extends ResponseError {
 
 
 export interface StoreApiInterface {
-  getInventoryRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetInventoryRawResponse>;
+  getInventoryRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<GetInventoryRawResponse>;
   getInventory: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<Record<string,
-number>>;
-  placeOrderRaw: (requestParameters: ApiPlaceOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<PlaceOrderRawResponse>;
-  placeOrder: (requestParameters: ApiPlaceOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
-  getOrderByIdRaw: (requestParameters: ApiGetOrderByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetOrderByIdRawResponse>;
-  getOrderById: (requestParameters: ApiGetOrderByIdRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
-  deleteOrderRaw: (requestParameters: ApiDeleteOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteOrderRawResponse>;
-  deleteOrder: (requestParameters: ApiDeleteOrderRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  number>>;
+  placeOrderRaw: (requestParameters: ApiPlaceOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<PlaceOrderRawResponse>;
+  placeOrder: (requestParameters: ApiPlaceOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
+  getOrderByIdRaw: (requestParameters: ApiGetOrderByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetOrderByIdRawResponse>;
+  getOrderById: (requestParameters: ApiGetOrderByIdRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Order>;
+  deleteOrderRaw: (requestParameters: ApiDeleteOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteOrderRawResponse>;
+  deleteOrder: (requestParameters: ApiDeleteOrderRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class StoreApi extends BaseAPI implements StoreApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/UserApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/UserApi.ts.golden
index c80c141c..f6422334 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/UserApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp-petstore/apis/UserApi.ts.golden
@@ -171,20 +171,34 @@ export class DeleteUserError extends ResponseError {
 
 
 export interface UserApiInterface {
-  createUserRaw: (requestParameters: ApiCreateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateUserRawResponse>;
-  createUser: (requestParameters: ApiCreateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
-  createUsersWithListInputRaw: (requestParameters: ApiCreateUsersWithListInputRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateUsersWithListInputRawResponse>;
-  createUsersWithListInput: (requestParameters: ApiCreateUsersWithListInputRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
-  loginUserRaw: (requestParameters: ApiLoginUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<LoginUserRawResponse>;
-  loginUser: (requestParameters: ApiLoginUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  logoutUserRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<LogoutUserRawResponse>;
+  createUserRaw: (requestParameters: ApiCreateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateUserRawResponse>;
+  createUser: (requestParameters: ApiCreateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
+  createUsersWithListInputRaw: (requestParameters: ApiCreateUsersWithListInputRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CreateUsersWithListInputRawResponse>;
+  createUsersWithListInput: (requestParameters: ApiCreateUsersWithListInputRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
+  loginUserRaw: (requestParameters: ApiLoginUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<LoginUserRawResponse>;
+  loginUser: (requestParameters: ApiLoginUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  logoutUserRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<LogoutUserRawResponse>;
   logoutUser: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  getUserByNameRaw: (requestParameters: ApiGetUserByNameRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByNameRawResponse>;
-  getUserByName: (requestParameters: ApiGetUserByNameRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
-  updateUserRaw: (requestParameters: ApiUpdateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdateUserRawResponse>;
-  updateUser: (requestParameters: ApiUpdateUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  deleteUserRaw: (requestParameters: ApiDeleteUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteUserRawResponse>;
-  deleteUser: (requestParameters: ApiDeleteUserRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  getUserByNameRaw: (requestParameters: ApiGetUserByNameRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetUserByNameRawResponse>;
+  getUserByName: (requestParameters: ApiGetUserByNameRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<User>;
+  updateUserRaw: (requestParameters: ApiUpdateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<UpdateUserRawResponse>;
+  updateUser: (requestParameters: ApiUpdateUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  deleteUserRaw: (requestParameters: ApiDeleteUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<DeleteUserRawResponse>;
+  deleteUser: (requestParameters: ApiDeleteUserRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class UserApi extends BaseAPI implements UserApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp/apis/DefaultApi.ts.golden
index 6900acc1..9971ee61 100644
--- a/tests/golden/typescript/typescript-fetch/ts-toolchain-vp/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-toolchain-vp/apis/DefaultApi.ts.golden
@@ -33,8 +33,10 @@ export class CreateContainerError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createContainerRaw: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
-  createContainer: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerImage>;
+  createContainerRaw: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
+  createContainer: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerImage>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/ts-type-guards/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/ts-type-guards/apis/DefaultApi.ts.golden
index 0322ca81..994da182 100644
--- a/tests/golden/typescript/typescript-fetch/ts-type-guards/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/ts-type-guards/apis/DefaultApi.ts.golden
@@ -30,8 +30,10 @@ export class HandleEventError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  handleEventRaw: (requestParameters: ApiHandleEventRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleEventRawResponse>;
-  handleEvent: (requestParameters: ApiHandleEventRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
+  handleEventRaw: (requestParameters: ApiHandleEventRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<HandleEventRawResponse>;
+  handleEvent: (requestParameters: ApiHandleEventRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-complex-union/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-complex-union/apis/DefaultApi.ts.golden
index 3635753b..da4e24bd 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-complex-union/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-complex-union/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestComplexUnionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testComplexUnionRaw: (requestParameters: ApiTestComplexUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestComplexUnionRawResponse>;
-  testComplexUnion: (requestParameters: ApiTestComplexUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testComplexUnionRaw: (requestParameters: ApiTestComplexUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestComplexUnionRawResponse>;
+  testComplexUnion: (requestParameters: ApiTestComplexUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-inline-discriminator-only/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-inline-discriminator-only/apis/DefaultApi.ts.golden
index a4a80252..2f0c49e2 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-inline-discriminator-only/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-inline-discriminator-only/apis/DefaultApi.ts.golden
@@ -40,8 +40,10 @@ export class CreateEventError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createEventRaw: (requestParameters: ApiCreateEventRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateEventRawResponse>;
-  createEvent: (requestParameters: ApiCreateEventRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Event>;
+  createEventRaw: (requestParameters: ApiCreateEventRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateEventRawResponse>;
+  createEvent: (requestParameters: ApiCreateEventRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Event>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-internally-tagged/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-internally-tagged/apis/DefaultApi.ts.golden
index 7e15bd93..bc68898a 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-internally-tagged/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-internally-tagged/apis/DefaultApi.ts.golden
@@ -33,8 +33,10 @@ export class CreateResourceError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createResourceRaw: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
-  createResource: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Resource>;
+  createResourceRaw: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
+  createResource: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Resource>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-long-names/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-long-names/apis/DefaultApi.ts.golden
index 8dfc6ad3..5933bf67 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-long-names/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-long-names/apis/DefaultApi.ts.golden
@@ -33,8 +33,11 @@ export class CreateResourceError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createResourceRaw: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
-  createResource: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<VeryLongDiscriminatedUnionTypeNameForTesting20260630>;
+  createResourceRaw: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
+  createResource: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<VeryLongDiscriminatedUnionTypeNameForTesting20260630>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-mixed-unit-and-allof/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-mixed-unit-and-allof/apis/DefaultApi.ts.golden
index e4d3de1c..15afe4dd 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-mixed-unit-and-allof/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-mixed-unit-and-allof/apis/DefaultApi.ts.golden
@@ -36,8 +36,10 @@ export class CreateResourceError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createResourceRaw: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
-  createResource: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Setup>;
+  createResourceRaw: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
+  createResource: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Setup>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-multiple/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-multiple/apis/DefaultApi.ts.golden
index e5d03eb0..e421b249 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-multiple/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-multiple/apis/DefaultApi.ts.golden
@@ -55,10 +55,14 @@ export class CreateVolumeError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createContainerRaw: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
-  createContainer: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerKind>;
-  createVolumeRaw: (requestParameters: ApiCreateVolumeRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateVolumeRawResponse>;
-  createVolume: (requestParameters: ApiCreateVolumeRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<VolumeKind>;
+  createContainerRaw: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
+  createContainer: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerKind>;
+  createVolumeRaw: (requestParameters: ApiCreateVolumeRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateVolumeRawResponse>;
+  createVolume: (requestParameters: ApiCreateVolumeRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<VolumeKind>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-with-refs/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-with-refs/apis/DefaultApi.ts.golden
index bba1fe03..fa32944a 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-with-refs/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-discriminated-union-with-refs/apis/DefaultApi.ts.golden
@@ -32,8 +32,10 @@ export class CreateContainerError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createContainerRaw: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
-  createContainer: (requestParameters: ApiCreateContainerRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerImage>;
+  createContainerRaw: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateContainerRawResponse>;
+  createContainer: (requestParameters: ApiCreateContainerRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<ContainerImage>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-intersection-allof/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-intersection-allof/apis/DefaultApi.ts.golden
index 8e296ec0..6eeabd3f 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-intersection-allof/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-intersection-allof/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestIntersectionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testIntersectionRaw: (requestParameters: ApiTestIntersectionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestIntersectionRawResponse>;
-  testIntersection: (requestParameters: ApiTestIntersectionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testIntersectionRaw: (requestParameters: ApiTestIntersectionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestIntersectionRawResponse>;
+  testIntersection: (requestParameters: ApiTestIntersectionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-intersection-with-nullable-reference/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-intersection-with-nullable-reference/apis/DefaultApi.ts.golden
index 2f608736..8d8d7410 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-intersection-with-nullable-reference/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-intersection-with-nullable-reference/apis/DefaultApi.ts.golden
@@ -51,10 +51,14 @@ export class GetTestError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  createTestRaw: (requestParameters: ApiCreateTestRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestRawResponse>;
-  createTest: (requestParameters: ApiCreateTestRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Baz>;
-  getTestRaw: (requestParameters: ApiGetTestRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetTestRawResponse>;
-  getTest: (requestParameters: ApiGetTestRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Baz>;
+  createTestRaw: (requestParameters: ApiCreateTestRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateTestRawResponse>;
+  createTest: (requestParameters: ApiCreateTestRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Baz>;
+  getTestRaw: (requestParameters: ApiGetTestRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<GetTestRawResponse>;
+  getTest: (requestParameters: ApiGetTestRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Baz>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-nested-union/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-nested-union/apis/DefaultApi.ts.golden
index 4aa243c4..52dd8e7f 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-nested-union/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-nested-union/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestNestedUnionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testNestedUnionRaw: (requestParameters: ApiTestNestedUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestNestedUnionRawResponse>;
-  testNestedUnion: (requestParameters: ApiTestNestedUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testNestedUnionRaw: (requestParameters: ApiTestNestedUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestNestedUnionRawResponse>;
+  testNestedUnion: (requestParameters: ApiTestNestedUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-simple-type-alias/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-simple-type-alias/apis/DefaultApi.ts.golden
index e6d9a977..228c311a 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-simple-type-alias/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-simple-type-alias/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestSimpleAliasError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testSimpleAliasRaw: (requestParameters: ApiTestSimpleAliasRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestSimpleAliasRawResponse>;
-  testSimpleAlias: (requestParameters: ApiTestSimpleAliasRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testSimpleAliasRaw: (requestParameters: ApiTestSimpleAliasRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestSimpleAliasRawResponse>;
+  testSimpleAlias: (requestParameters: ApiTestSimpleAliasRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-union-mixed/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-union-mixed/apis/DefaultApi.ts.golden
index 6f4b7574..632c55d3 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-union-mixed/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-union-mixed/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestMixedUnionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testMixedUnionRaw: (requestParameters: ApiTestMixedUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestMixedUnionRawResponse>;
-  testMixedUnion: (requestParameters: ApiTestMixedUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testMixedUnionRaw: (requestParameters: ApiTestMixedUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestMixedUnionRawResponse>;
+  testMixedUnion: (requestParameters: ApiTestMixedUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-any/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-any/apis/DefaultApi.ts.golden
index 70dbe651..fa731418 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-any/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-any/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestUnionWithAnyError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testUnionWithAnyRaw: (requestParameters: ApiTestUnionWithAnyRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionWithAnyRawResponse>;
-  testUnionWithAny: (requestParameters: ApiTestUnionWithAnyRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Config>;
+  testUnionWithAnyRaw: (requestParameters: ApiTestUnionWithAnyRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionWithAnyRawResponse>;
+  testUnionWithAny: (requestParameters: ApiTestUnionWithAnyRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Config>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-inline-objects/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-inline-objects/apis/DefaultApi.ts.golden
index 20e2f4a4..e3c2f80b 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-inline-objects/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-inline-objects/apis/DefaultApi.ts.golden
@@ -31,8 +31,11 @@ export class TestUnionWithInlineObjectsError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testUnionWithInlineObjectsRaw: (requestParameters: ApiTestUnionWithInlineObjectsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionWithInlineObjectsRawResponse>;
-  testUnionWithInlineObjects: (requestParameters: ApiTestUnionWithInlineObjectsRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testUnionWithInlineObjectsRaw: (requestParameters: ApiTestUnionWithInlineObjectsRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<TestUnionWithInlineObjectsRawResponse>;
+  testUnionWithInlineObjects: (requestParameters: ApiTestUnionWithInlineObjectsRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-interfaces/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-interfaces/apis/DefaultApi.ts.golden
index 83de7ad9..4442ed1f 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-interfaces/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-interfaces/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestUnionError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testUnionRaw: (requestParameters: ApiTestUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionRawResponse>;
-  testUnion: (requestParameters: ApiTestUnionRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testUnionRaw: (requestParameters: ApiTestUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionRawResponse>;
+  testUnion: (requestParameters: ApiTestUnionRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-primitives/apis/DefaultApi.ts.golden b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-primitives/apis/DefaultApi.ts.golden
index 04c2c66e..c8b84d32 100644
--- a/tests/golden/typescript/typescript-fetch/type-aliases-union-with-primitives/apis/DefaultApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/type-aliases-union-with-primitives/apis/DefaultApi.ts.golden
@@ -31,8 +31,10 @@ export class TestUnionPrimitivesError extends ResponseError {
 
 
 export interface DefaultApiInterface {
-  testUnionPrimitivesRaw: (requestParameters: ApiTestUnionPrimitivesRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionPrimitivesRawResponse>;
-  testUnionPrimitives: (requestParameters: ApiTestUnionPrimitivesRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
+  testUnionPrimitivesRaw: (requestParameters: ApiTestUnionPrimitivesRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<TestUnionPrimitivesRawResponse>;
+  testUnionPrimitives: (requestParameters: ApiTestUnionPrimitivesRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<Foo>;
 }
 
 export class DefaultApi extends BaseAPI implements DefaultApiInterface {
diff --git a/tests/golden/typescript/typescript-fetch/typed-error-responses/apis/ResourcesApi.ts.golden b/tests/golden/typescript/typescript-fetch/typed-error-responses/apis/ResourcesApi.ts.golden
index c398dfb1..64442112 100644
--- a/tests/golden/typescript/typescript-fetch/typed-error-responses/apis/ResourcesApi.ts.golden
+++ b/tests/golden/typescript/typescript-fetch/typed-error-responses/apis/ResourcesApi.ts.golden
@@ -149,12 +149,18 @@ export class CreateResourceWithWildcardSuccessError extends ResponseError {
 
 
 export interface ResourcesApiInterface {
-  checkNoSuccessBodyRaw: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<CheckNoSuccessBodyRawResponse>;
+  checkNoSuccessBodyRaw: (initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CheckNoSuccessBodyRawResponse>;
   checkNoSuccessBody: (initOverrides?: RequestInit | InitOverrideFunction) => Promise<void>;
-  createResourceRaw: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
-  createResource: (requestParameters: ApiCreateResourceRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreatedResource>;
-  createResourceWithWildcardSuccessRaw: (requestParameters: ApiCreateResourceWithWildcardSuccessRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceWithWildcardSuccessRawResponse>;
-  createResourceWithWildcardSuccess: (requestParameters: ApiCreateResourceWithWildcardSuccessRequest, initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreatedResource>;
+  createResourceRaw: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreateResourceRawResponse>;
+  createResource: (requestParameters: ApiCreateResourceRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreatedResource>;
+  createResourceWithWildcardSuccessRaw: (requestParameters: ApiCreateResourceWithWildcardSuccessRequest,
+  initOverrides?: RequestInit
+  | InitOverrideFunction) => Promise<CreateResourceWithWildcardSuccessRawResponse>;
+  createResourceWithWildcardSuccess: (requestParameters: ApiCreateResourceWithWildcardSuccessRequest,
+  initOverrides?: RequestInit | InitOverrideFunction) => Promise<CreatedResource>;
 }
 
 export class ResourcesApi extends BaseAPI implements ResourcesApiInterface {
diff --git a/tests/golden_tests_typescript_fetch.rs b/tests/golden_tests_typescript_fetch.rs
index 51b8ac1d..909f2820 100644
--- a/tests/golden_tests_typescript_fetch.rs
+++ b/tests/golden_tests_typescript_fetch.rs
@@ -82,6 +82,7 @@ fn get_golden_test_cases() -> HashMap<&'static str, &'static str> {
         ("response-body-no-response-body", "valid/response-body/no-response-body.yaml"),
         ("typed-error-responses", "valid/typed-error-responses.yaml"),
         ("response-dispatch", "valid/typescript-response-dispatch.yaml"),
+        ("api-interface", "valid/typescript-api-interface.yaml"),
         ("nested-nullable", "valid/nested-nullable.yaml"),
 
         ("additional-properties", "valid/additional-properties/additional-properties.yaml"),
@@ -174,6 +175,7 @@ generate_golden_tests! {
     test_response_body_no_response_body_golden: "response-body-no-response-body",
     test_typed_error_responses_golden: "typed-error-responses",
     test_response_dispatch_golden: "response-dispatch",
+    test_api_interface_golden: "api-interface",
 
     test_enum_repr_golden: "enum-repr",
     test_additional_properties_golden: "additional-properties",