typed-openapi 2.1.2 → 2.2.0

package/dist/{chunk-UNKLDND3.js → chunk-IB6GEWS7.js}

@@ -5,7 +5,7 @@ import {
   generateFile,
   generateTanstackQueryFile,
   mapOpenApiEndpoints
-} from "./chunk-X4A4YQN7.js";
+} from "./chunk-QGMS7IBQ.js";
 import {
   prettify
 } from "./chunk-KAEXXJ7X.js";
@@ -35,13 +35,12 @@ var generateDefaultFetcher = (options) => {
  * - Basic error handling
  *
  * Usage:
- * 1. Replace './generated/api' with your actual generated file path
+ * 1. Replace './${clientPath}' with your actual generated file path
  * 2. Set your ${envApiBaseUrl}
  * 3. Customize error handling and headers as needed
  */
 
-// @ts-ignore
-import { type Fetcher, createApiClient } from "./${clientPath}";
+import { type Fetcher, createApiClient } from "${clientPath}";
 
 // Basic configuration
 const ${envApiBaseUrl} = process.env["${envApiBaseUrl}"] || "https://api.example.com";
@@ -49,32 +48,17 @@ const ${envApiBaseUrl} = process.env["${envApiBaseUrl}"] || "https://api.example
 /**
  * Simple fetcher implementation without external dependencies
  */
-export const ${fetcherName}: Fetcher = async (method, apiUrl, params) => {
+const ${fetcherName}: Fetcher["fetch"] = async (input) => {
   const headers = new Headers();
 
-  // Replace path parameters (supports both {param} and :param formats)
-  const actualUrl = replacePathParams(apiUrl, (params?.path ?? {}) as Record<string, string>);
-  const url = new URL(actualUrl);
-
   // Handle query parameters
-  if (params?.query) {
-    const searchParams = new URLSearchParams();
-    Object.entries(params.query).forEach(([key, value]) => {
-      if (value != null) {
-        // Skip null/undefined values
-        if (Array.isArray(value)) {
-          value.forEach((val) => val != null && searchParams.append(key, String(val)));
-        } else {
-          searchParams.append(key, String(value));
-        }
-      }
-    });
-    url.search = searchParams.toString();
+  if (input.urlSearchParams) {
+    input.url.search = input.urlSearchParams.toString();
   }
 
   // Handle request body for mutation methods
-  const body = ["post", "put", "patch", "delete"].includes(method.toLowerCase())
-    ? JSON.stringify(params?.body)
+  const body = ["post", "put", "patch", "delete"].includes(input.method.toLowerCase())
+    ? JSON.stringify(input.parameters?.body)
     : undefined;
 
   if (body) {
@@ -82,35 +66,25 @@ export const ${fetcherName}: Fetcher = async (method, apiUrl, params) => {
   }
 
   // Add custom headers
-  if (params?.header) {
-    Object.entries(params.header).forEach(([key, value]) => {
+  if (input.parameters?.header) {
+    Object.entries(input.parameters.header).forEach(([key, value]) => {
       if (value != null) {
         headers.set(key, String(value));
       }
     });
   }
 
-  const response = await fetch(url, {
-    method: method.toUpperCase(),
+  const response = await fetch(input.url, {
+    method: input.method.toUpperCase(),
     ...(body && { body }),
     headers,
+    ...input.overrides,
   });
 
   return response;
 };
 
-/**
- * Replace path parameters in URL
- * Supports both OpenAPI format {param} and Express format :param
- */
-export function replacePathParams(url: string, params: Record<string, string>): string {
-  return url
-    .replace(/{(\\w+)}/g, function(_, key) { return params[key] || '{' + key + '}'; })
-    .replace(/:([a-zA-Z0-9_]+)/g, function(_, key) { return params[key] || ':' + key; });
-}
-
-export const ${apiName} = createApiClient(${fetcherName}, API_BASE_URL);
-`;
+export const ${apiName} = createApiClient({ fetch: ${fetcherName} }, API_BASE_URL);`;
 };
 
 // src/generate-client-files.ts
@@ -183,7 +157,7 @@ async function generateClientFiles(input, options) {
   if (options.defaultFetcher) {
     const defaultFetcherContent = generateDefaultFetcher({
       envApiBaseUrl: options.defaultFetcher.envApiBaseUrl,
-      clientPath: options.defaultFetcher.clientPath ?? basename(outputPath),
+      clientPath: options.defaultFetcher.clientPath ?? join(dirname(outputPath), basename(outputPath)),
       fetcherName: options.defaultFetcher.fetcherName,
       apiName: options.defaultFetcher.apiName
     });

package/dist/{chunk-X4A4YQN7.js → chunk-QGMS7IBQ.js}

@@ -574,7 +574,21 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
   responseHeaders?: TConfig["responseHeaders"]
 };
 
-export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
+export interface Fetcher {
+    decodePathParams?: (path: string, pathParams: Record<string, string>) => string
+    encodeSearchParams?: (searchParams: Record<string, unknown> | undefined) => URLSearchParams
+    //
+    fetch: (input: {
+      method: Method;
+      url: URL;
+      urlSearchParams?: URLSearchParams | undefined;
+      parameters?: EndpointParameters | undefined;
+      path: string;
+      overrides?: RequestInit;
+      throwOnStatusError?: boolean
+    }) => Promise<Response>;
+    parseResponseData?: (response: Response) => Promise<unknown>
+}
 
 export const successStatusCodes = [${ctx.successStatusCodes.join(",")}] as const;
 export type SuccessStatusCode = typeof successStatusCodes[number];
@@ -647,9 +661,12 @@ type RequiredKeys<T> = {
 }[keyof T];
 
 type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [config: T];
+type NotNever<T> = [T] extends [never] ? false : true;
 
 // </ApiClientTypes>
 `;
+  const infer = inferByRuntime[ctx.runtime];
+  const InferTEndpoint = match(ctx.runtime).with("zod", "yup", () => infer(`TEndpoint`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`)).otherwise(() => `TEndpoint`);
   const apiClient = `
 // <TypedResponseError>
 export class TypedResponseError extends Error {
@@ -663,6 +680,7 @@ export class TypedResponseError extends Error {
   }
 }
 // </TypedResponseError>
+
 // <ApiClient>
 export class ApiClient {
   baseUrl: string = "";
@@ -676,64 +694,86 @@ export class ApiClient {
     return this;
   }
 
-  parseResponse = async <T>(response: Response): Promise<T> => {
-    const contentType = response.headers.get('content-type');
-    if (contentType?.includes('application/json')) {
-      return response.json();
+  /**
+   * Replace path parameters in URL
+   * Supports both OpenAPI format {param} and Express format :param
+   */
+  defaultDecodePathParams = (url: string, params: Record<string, string>): string => {
+    return url
+      .replace(/{(\\w+)}/g, (_, key: string) => params[key] || \`{\${key}}\`)
+      .replace(/:([a-zA-Z0-9_]+)/g, (_, key: string) => params[key] || \`:\${key}\`);
+  }
+
+  /** Uses URLSearchParams, skips null/undefined values */
+  defaultEncodeSearchParams = (queryParams: Record<string, unknown> | undefined): URLSearchParams | undefined => {
+    if (!queryParams) return;
+
+    const searchParams = new URLSearchParams();
+    Object.entries(queryParams).forEach(([key, value]) => {
+      if (value != null) {
+        // Skip null/undefined values
+        if (Array.isArray(value)) {
+          value.forEach((val) => val != null && searchParams.append(key, String(val)));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      }
+    });
+
+    return searchParams;
+  }
+
+  defaultParseResponseData = async (response: Response): Promise<unknown> => {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.startsWith("text/")) {
+      return (await response.text())
+    }
+
+    if (contentType === "application/octet-stream") {
+      return (await response.arrayBuffer())
+    }
+
+    if (
+      contentType.includes("application/json") ||
+      (contentType.includes("application/") && contentType.includes("json")) ||
+      contentType === "*/*"
+      ) {
+      try {
+        return await response.json();
+      } catch {
+        return undefined
+      }
     }
-    return response.text() as unknown as T;
+
+    return
   }
 
   ${Object.entries(byMethods).map(([method, endpointByMethod]) => {
     const capitalizedMethod = capitalize2(method);
-    const infer = inferByRuntime[ctx.runtime];
     return endpointByMethod.length ? `// <ApiClient.${method}>
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
-      ...params: MaybeOptionalArg<${match(ctx.runtime).with("zod", "yup", () => infer(`TEndpoint["parameters"]`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`).otherwise(() => `TEndpoint["parameters"]`)} & { withResponse?: false; throwOnStatusError?: boolean }>
-    ): Promise<${match(ctx.runtime).with("zod", "yup", () => infer(`InferResponseByStatus<TEndpoint, SuccessStatusCode>`)).with(
-      "arktype",
-      "io-ts",
-      "typebox",
-      "valibot",
-      () => `InferResponseByStatus<${infer(`TEndpoint`)}, SuccessStatusCode>["data"]`
-    ).otherwise(() => `Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]`)}>;
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean })
+      >
+    ): Promise<Extract<InferResponseByStatus<${InferTEndpoint}, SuccessStatusCode>, { data: {} }>["data"]>;
 
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
-      ...params: MaybeOptionalArg<${match(ctx.runtime).with("zod", "yup", () => infer(`TEndpoint["parameters"]`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`).otherwise(() => `TEndpoint["parameters"]`)} & { withResponse: true; throwOnStatusError?: boolean }>
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean })
+      >
     ): Promise<SafeApiResponse<TEndpoint>>;
 
-    ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
+    ${method}<Path extends keyof ${capitalizedMethod}Endpoints, _TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
       ...params: MaybeOptionalArg<any>
     ): Promise<any> {
-      const requestParams = params[0];
-      const withResponse = requestParams?.withResponse;
-      const { withResponse: _, throwOnStatusError = withResponse ? false : true, ...fetchParams } = requestParams || {};
-
-      const promise = this.fetcher("${method}", this.baseUrl + path, Object.keys(fetchParams).length ? requestParams : undefined)
-        .then(async (response) => {
-          const data = await this.parseResponse(response);
-          const typedResponse = Object.assign(response, {
-            data: data,
-            json: () => Promise.resolve(data)
-          }) as SafeApiResponse<TEndpoint>;
-
-          if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
-            throw new TypedResponseError(typedResponse as never);
-          }
-
-          return withResponse ? typedResponse : data;
-        });
-
-        return promise ${match(ctx.runtime).with("zod", "yup", () => `as Promise<${infer(`InferResponseByStatus<TEndpoint, SuccessStatusCode>`)}>`).with(
-      "arktype",
-      "io-ts",
-      "typebox",
-      "valibot",
-      () => `as Promise<InferResponseByStatus<${infer(`TEndpoint`)}, SuccessStatusCode>["data"]>`
-    ).otherwise(() => `as Promise<Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]>`)}
+        return this.request("${method}", path, ...params);
     }
     // </ApiClient.${method}>
     ` : "";
@@ -750,19 +790,74 @@ export class ApiClient {
     >(
       method: TMethod,
       path: TPath,
-      ...params: MaybeOptionalArg<${match(ctx.runtime).with(
-    "zod",
-    "yup",
-    () => inferByRuntime[ctx.runtime](`TEndpoint extends { parameters: infer Params } ? Params : never`)
-  ).with(
-    "arktype",
-    "io-ts",
-    "typebox",
-    "valibot",
-    () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`
-  ).otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
-    : Promise<SafeApiResponse<TEndpoint>> {
-      return this.fetcher(method, this.baseUrl + (path as string), params[0] as EndpointParameters) as Promise<SafeApiResponse<TEndpoint>>;
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean })
+      >
+    ): Promise<Extract<InferResponseByStatus<${InferTEndpoint}, SuccessStatusCode>, { data: {} }>["data"]>
+
+    request<
+      TMethod extends keyof EndpointByMethod,
+      TPath extends keyof EndpointByMethod[TMethod],
+      TEndpoint extends EndpointByMethod[TMethod][TPath]
+    >(
+      method: TMethod,
+      path: TPath,
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean })
+      >
+    ): Promise<SafeApiResponse<TEndpoint>>;
+
+    request<
+      TMethod extends keyof EndpointByMethod,
+      TPath extends keyof EndpointByMethod[TMethod],
+      TEndpoint extends EndpointByMethod[TMethod][TPath]
+    >(
+      method: TMethod,
+      path: TPath,
+      ...params: MaybeOptionalArg<any>
+    ): Promise<any> {
+      const requestParams = params[0];
+      const withResponse = requestParams?.withResponse;
+      const { withResponse: _, throwOnStatusError = withResponse ? false : true, overrides, ...fetchParams } = requestParams || {};
+
+      const parametersToSend: EndpointParameters = {};
+      if (requestParams?.body !== undefined) (parametersToSend as any).body = requestParams.body;
+      if (requestParams?.query !== undefined) (parametersToSend as any).query = requestParams.query;
+      if (requestParams?.header !== undefined) (parametersToSend as any).header = requestParams.header;
+      if (requestParams?.path !== undefined) (parametersToSend as any).path = requestParams.path;
+
+      const resolvedPath = (this.fetcher.decodePathParams ?? this.defaultDecodePathParams)(this.baseUrl + (path as string), (parametersToSend.path ?? {}) as Record<string, string>);
+      const url = new URL(resolvedPath);
+      const urlSearchParams = (this.fetcher.encodeSearchParams ?? this.defaultEncodeSearchParams)(parametersToSend.query);
+
+      const promise = this.fetcher.fetch({
+        method: method,
+        path: (path as string),
+        url,
+        urlSearchParams,
+        parameters: Object.keys(fetchParams).length ? fetchParams : undefined,
+        overrides,
+        throwOnStatusError
+      })
+        .then(async (response) => {
+          const data = await (this.fetcher.parseResponseData ?? this.defaultParseResponseData)(response);
+          const typedResponse = Object.assign(response, {
+            data: data,
+            json: () => Promise.resolve(data)
+          }) as SafeApiResponse<TEndpoint>;
+
+          if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
+            throw new TypedResponseError(typedResponse as never);
+          }
+
+          return withResponse ? typedResponse : data;
+        });
+
+        return promise as Extract<InferResponseByStatus<${InferTEndpoint}, SuccessStatusCode>, { data: {} }>["data"]
     }
     // </ApiClient.request>
 }
@@ -1171,7 +1266,7 @@ var mapOpenApiEndpoints = (doc, options) => {
         endpoint.parameters = Object.keys(params).length ? params : void 0;
       }
       const allResponses = {};
-      const allHeaders = {};
+      const allResponseHeaders = {};
       Object.entries(operation.responses ?? {}).map(([status, responseOrRef]) => {
         const responseObj = refs.unwrap(responseOrRef);
         const content = responseObj?.content;
@@ -1179,11 +1274,19 @@ var mapOpenApiEndpoints = (doc, options) => {
         if (content && mediaTypes.length) {
           mediaTypes.forEach((mediaType) => {
             const schema = content[mediaType] ? content[mediaType].schema ?? {} : {};
-            const t2 = createBoxFactory(schema, ctx);
             const mediaTypeResponse = openApiSchemaToTs({ schema, ctx });
             if (allResponses[status]) {
+              const t2 = createBoxFactory(
+                {
+                  oneOf: [
+                    ...allResponses[status].schema.oneOf ? allResponses[status].schema.oneOf : [allResponses[status].schema],
+                    schema
+                  ]
+                },
+                ctx
+              );
               allResponses[status] = t2.union([
-                ...Array.isArray(allResponses[status]) ? allResponses[status] : [allResponses[status]],
+                ...allResponses[status].type === "union" ? allResponses[status].params.types : [allResponses[status]],
                 mediaTypeResponse
               ]);
             } else {
@@ -1193,10 +1296,18 @@ var mapOpenApiEndpoints = (doc, options) => {
         } else {
           const schema = {};
           const unknown = openApiSchemaToTs({ schema: {}, ctx });
-          const t2 = createBoxFactory(schema, ctx);
           if (allResponses[status]) {
+            const t2 = createBoxFactory(
+              {
+                oneOf: [
+                  ...allResponses[status].schema.oneOf ? allResponses[status].schema.oneOf : [allResponses[status].schema],
+                  schema
+                ]
+              },
+              ctx
+            );
             allResponses[status] = t2.union([
-              ...Array.isArray(allResponses[status]) ? allResponses[status] : [allResponses[status]],
+              ...allResponses[status].type === "union" ? allResponses[status].params.types : [allResponses[status]],
               unknown
             ]);
           } else {
@@ -1219,15 +1330,15 @@ var mapOpenApiEndpoints = (doc, options) => {
             {}
           );
           if (Object.keys(mappedHeaders).length) {
-            allHeaders[status] = t.object(mappedHeaders);
+            allResponseHeaders[status] = t.object(mappedHeaders);
           }
         }
       });
       if (Object.keys(allResponses).length > 0) {
         endpoint.responses = allResponses;
       }
-      if (Object.keys(allHeaders).length) {
-        endpoint.responseHeaders = allHeaders;
+      if (Object.keys(allResponseHeaders).length) {
+        endpoint.responseHeaders = allResponseHeaders;
       }
       endpointList.push(endpoint);
     });
@@ -1314,7 +1425,10 @@ var generateTanstackQueryFile = async (ctx) => {
       ${Array.from(endpointMethods).map(
     (method) => `
         // <ApiClient.${method}>
-        ${method}<Path extends keyof ${capitalize4(method)}Endpoints, TEndpoint extends ${capitalize4(method)}Endpoints[Path]>(
+        ${method}<
+            Path extends keyof ${capitalize4(method)}Endpoints,
+            TEndpoint extends ${capitalize4(method)}Endpoints[Path]
+        >(
             path: Path,
             ...params: MaybeOptionalArg<TEndpoint["parameters"]>
         ) {
@@ -1329,28 +1443,14 @@ var generateTanstackQueryFile = async (ctx) => {
                         const requestParams = {
                             ...(params[0] || {}),
                             ...(queryKey[0] || {}),
-                            signal,
+                            overrides: { signal },
                             withResponse: false as const
                         };
-                        const res = await this.client.${method}(path, requestParams);
+                        const res = await this.client.${method}(path, requestParams as never);
                         return res as Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"];
                     },
                     queryKey: queryKey
                 }),
-                mutationFn: {} as "You need to pass .mutationOptions to the useMutation hook",
-                mutationOptions: {
-                    mutationKey: queryKey,
-                    mutationFn: async (localOptions: TEndpoint extends { parameters: infer Parameters} ? Parameters: never) => {
-                        const requestParams = {
-                            ...(params[0] || {}),
-                            ...(queryKey[0] || {}),
-                            ...(localOptions || {}),
-                            withResponse: false as const
-                        };
-                        const res = await this.client.${method}(path, requestParams);
-                        return res as Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"];
-                    }
-                }
             };
 
             return query
@@ -1384,40 +1484,54 @@ var generateTanstackQueryFile = async (ctx) => {
                 : Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]
             ) => TSelection;
              throwOnStatusError?: boolean
+             throwOnError?: boolean | ((error: TError) => boolean)
         }) {
             const mutationKey = [{ method, path }] as const;
+            const mutationFn = async <TLocalWithResponse extends boolean = TWithResponse, TLocalSelection = TLocalWithResponse extends true
+                ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
+                : Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]>
+            (params: (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
+                withResponse?: TLocalWithResponse;
+                throwOnStatusError?: boolean;
+                overrides?: RequestInit;
+            }): Promise<TLocalSelection> => {
+                const withResponse = params.withResponse ??options?.withResponse ?? false;
+                const throwOnStatusError = params.throwOnStatusError ?? options?.throwOnStatusError ?? (withResponse ? false : true);
+                const selectFn = options?.selectFn;
+                const response = await (this.client as any)[method](path, {
+                    ...params as any,
+                    withResponse: true,
+                    throwOnStatusError: false,
+                });
+
+                if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
+                    throw new TypedResponseError(response as never);
+                }
+
+                // Return just the data if withResponse is false, otherwise return the full response
+                const finalResponse = withResponse ? response : response.data;
+                const res = selectFn ? selectFn(finalResponse as any) : finalResponse;
+                return res as never;
+            };
             return {
             /** type-only property if you need easy access to the endpoint params */
             "~endpoint": {} as TEndpoint,
             mutationKey: mutationKey,
             mutationFn: {} as "You need to pass .mutationOptions to the useMutation hook",
             mutationOptions: {
+                throwOnError: options?.throwOnError as boolean | ((error: TError) => boolean),
                 mutationKey: mutationKey,
-                mutationFn: async <TLocalWithResponse extends boolean = TWithResponse, TLocalSelection = TLocalWithResponse extends true
-                    ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
-                    : Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]>
-                (params: (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
-                    withResponse?: TLocalWithResponse;
-                    throwOnStatusError?: boolean;
-                }): Promise<TLocalSelection> => {
-                    const withResponse = params.withResponse ??options?.withResponse ?? false;
-                    const throwOnStatusError = params.throwOnStatusError ?? options?.throwOnStatusError ?? (withResponse ? false : true);
-                    const selectFn = options?.selectFn;
-                    const response = await (this.client as any)[method](path, { ...params as any, withResponse: true, throwOnStatusError: false });
-
-                    if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
-                        throw new TypedResponseError(response as never);
-                    }
-
-                    // Return just the data if withResponse is false, otherwise return the full response
-                    const finalResponse = withResponse ? response : response.data;
-                    const res = selectFn ? selectFn(finalResponse as any) : finalResponse;
-                    return res as never;
+                mutationFn: mutationFn,
+            } as Omit<import("@tanstack/react-query").UseMutationOptions<
+                TSelection,
+                TError,
+                (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
+                withResponse?: boolean;
+                throwOnStatusError?: boolean;
                 }
-            } satisfies import("@tanstack/react-query").UseMutationOptions<TSelection, TError, (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
-                    withResponse?: boolean;
-                    throwOnStatusError?: boolean;
-                }>,
+            >, "mutationFn"> & {
+                mutationFn: typeof mutationFn
+            },
         }
     }
         // </ApiClient.request>

package/dist/cli.js

@@ -1,9 +1,9 @@
 import {
   generateClientFiles
-} from "./chunk-UNKLDND3.js";
+} from "./chunk-IB6GEWS7.js";
 import {
   allowedRuntimes
-} from "./chunk-X4A4YQN7.js";
+} from "./chunk-QGMS7IBQ.js";
 import "./chunk-KAEXXJ7X.js";
 
 // src/cli.ts

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   openApiSchemaToTs,
   tsFactory,
   unwrap
-} from "./chunk-X4A4YQN7.js";
+} from "./chunk-QGMS7IBQ.js";
 import "./chunk-KAEXXJ7X.js";
 export {
   createBoxFactory,

package/dist/node.export.js

@@ -1,7 +1,7 @@
 import {
   generateClientFiles
-} from "./chunk-UNKLDND3.js";
-import "./chunk-X4A4YQN7.js";
+} from "./chunk-IB6GEWS7.js";
+import "./chunk-QGMS7IBQ.js";
 import "./chunk-KAEXXJ7X.js";
 export {
   generateClientFiles

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typed-openapi",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "exports": {
@@ -34,6 +34,7 @@
     "@types/node": "^22.15.17",
     "@types/prettier": "3.0.0",
     "msw": "2.10.5",
+    "tstyche": "4.3.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
     "vitest": "^3.1.3",
@@ -67,6 +68,7 @@
     "dev": "tsup --watch",
     "build": "tsup",
     "test": "vitest",
+    "test:types": "tstyche",
     "gen:runtime": "node bin.js ./tests/samples/petstore.yaml --output ./tmp/generated-client.ts --tanstack generated-tanstack.ts --default-fetcher",
     "test:runtime:run": "vitest run tests/integration-runtime-msw.test.ts",
     "test:runtime": "pnpm run gen:runtime && pnpm run test:runtime:run",

package/src/default-fetcher.generator.ts

@@ -22,13 +22,12 @@ export const generateDefaultFetcher = (options: {
  * - Basic error handling
  *
  * Usage:
- * 1. Replace './generated/api' with your actual generated file path
+ * 1. Replace './${clientPath}' with your actual generated file path
  * 2. Set your ${envApiBaseUrl}
  * 3. Customize error handling and headers as needed
  */
 
-// @ts-ignore
-import { type Fetcher, createApiClient } from "./${clientPath}";
+import { type Fetcher, createApiClient } from "${clientPath}";
 
 // Basic configuration
 const ${envApiBaseUrl} = process.env["${envApiBaseUrl}"] || "https://api.example.com";
@@ -36,32 +35,17 @@ const ${envApiBaseUrl} = process.env["${envApiBaseUrl}"] || "https://api.example
 /**
  * Simple fetcher implementation without external dependencies
  */
-export const ${fetcherName}: Fetcher = async (method, apiUrl, params) => {
+const ${fetcherName}: Fetcher["fetch"] = async (input) => {
   const headers = new Headers();
 
-  // Replace path parameters (supports both {param} and :param formats)
-  const actualUrl = replacePathParams(apiUrl, (params?.path ?? {}) as Record<string, string>);
-  const url = new URL(actualUrl);
-
   // Handle query parameters
-  if (params?.query) {
-    const searchParams = new URLSearchParams();
-    Object.entries(params.query).forEach(([key, value]) => {
-      if (value != null) {
-        // Skip null/undefined values
-        if (Array.isArray(value)) {
-          value.forEach((val) => val != null && searchParams.append(key, String(val)));
-        } else {
-          searchParams.append(key, String(value));
-        }
-      }
-    });
-    url.search = searchParams.toString();
+  if (input.urlSearchParams) {
+    input.url.search = input.urlSearchParams.toString();
   }
 
   // Handle request body for mutation methods
-  const body = ["post", "put", "patch", "delete"].includes(method.toLowerCase())
-    ? JSON.stringify(params?.body)
+  const body = ["post", "put", "patch", "delete"].includes(input.method.toLowerCase())
+    ? JSON.stringify(input.parameters?.body)
     : undefined;
 
   if (body) {
@@ -69,33 +53,23 @@ export const ${fetcherName}: Fetcher = async (method, apiUrl, params) => {
   }
 
   // Add custom headers
-  if (params?.header) {
-    Object.entries(params.header).forEach(([key, value]) => {
+  if (input.parameters?.header) {
+    Object.entries(input.parameters.header).forEach(([key, value]) => {
       if (value != null) {
         headers.set(key, String(value));
       }
     });
   }
 
-  const response = await fetch(url, {
-    method: method.toUpperCase(),
+  const response = await fetch(input.url, {
+    method: input.method.toUpperCase(),
     ...(body && { body }),
     headers,
+    ...input.overrides,
   });
 
   return response;
 };
 
-/**
- * Replace path parameters in URL
- * Supports both OpenAPI format {param} and Express format :param
- */
-export function replacePathParams(url: string, params: Record<string, string>): string {
-  return url
-    .replace(/\{(\\w+)\}/g, function(_, key) { return params[key] || '{' + key + '}'; })
-    .replace(/:([a-zA-Z0-9_]+)/g, function(_, key) { return params[key] || ':' + key; });
-}
-
-export const ${apiName} = createApiClient(${fetcherName}, API_BASE_URL);
-`;
+export const ${apiName} = createApiClient({ fetch: ${fetcherName} }, API_BASE_URL);`;
 };

package/src/generate-client-files.ts

@@ -110,7 +110,7 @@ export async function generateClientFiles(input: string, options: GenerateClient
   if (options.defaultFetcher) {
     const defaultFetcherContent = generateDefaultFetcher({
       envApiBaseUrl: options.defaultFetcher.envApiBaseUrl,
-      clientPath: options.defaultFetcher.clientPath ?? basename(outputPath),
+      clientPath: options.defaultFetcher.clientPath ?? join(dirname(outputPath), basename(outputPath)),
       fetcherName: options.defaultFetcher.fetcherName,
       apiName: options.defaultFetcher.apiName,
     });

package/src/generator.ts

@@ -233,11 +233,7 @@ const generateEndpointSchemaList = (ctx: GeneratorContext) => {
           : "parameters: never,"
       }
       ${endpoint.responses ? `responses: ${generateResponsesObject(endpoint.responses, ctx)},` : ""}
-      ${
-        endpoint.responseHeaders
-          ? `responseHeaders: ${responseHeadersObjectToString(endpoint.responseHeaders)},`
-          : ""
-      }
+      ${endpoint.responseHeaders ? `responseHeaders: ${responseHeadersObjectToString(endpoint.responseHeaders)},` : ""}
     }\n`;
   });
 
@@ -329,7 +325,21 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
   responseHeaders?: TConfig["responseHeaders"]
 };
 
-export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
+export interface Fetcher {
+    decodePathParams?: (path: string, pathParams: Record<string, string>) => string
+    encodeSearchParams?: (searchParams: Record<string, unknown> | undefined) => URLSearchParams
+    //
+    fetch: (input: {
+      method: Method;
+      url: URL;
+      urlSearchParams?: URLSearchParams | undefined;
+      parameters?: EndpointParameters | undefined;
+      path: string;
+      overrides?: RequestInit;
+      throwOnStatusError?: boolean
+    }) => Promise<Response>;
+    parseResponseData?: (response: Response) => Promise<unknown>
+}
 
 export const successStatusCodes = [${ctx.successStatusCodes.join(",")}] as const;
 export type SuccessStatusCode = typeof successStatusCodes[number];
@@ -402,10 +412,17 @@ type RequiredKeys<T> = {
 }[keyof T];
 
 type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [config: T];
+type NotNever<T> = [T] extends [never] ? false : true;
 
 // </ApiClientTypes>
 `;
 
+  const infer = inferByRuntime[ctx.runtime];
+  const InferTEndpoint = match(ctx.runtime)
+    .with("zod", "yup", () => infer(`TEndpoint`))
+    .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`))
+    .otherwise(() => `TEndpoint`);
+
   const apiClient = `
 // <TypedResponseError>
 export class TypedResponseError extends Error {
@@ -419,6 +436,7 @@ export class TypedResponseError extends Error {
   }
 }
 // </TypedResponseError>
+
 // <ApiClient>
 export class ApiClient {
   baseUrl: string = "";
@@ -432,79 +450,89 @@ export class ApiClient {
     return this;
   }
 
-  parseResponse = async <T>(response: Response): Promise<T> => {
-    const contentType = response.headers.get('content-type');
-    if (contentType?.includes('application/json')) {
-      return response.json();
+  /**
+   * Replace path parameters in URL
+   * Supports both OpenAPI format {param} and Express format :param
+   */
+  defaultDecodePathParams = (url: string, params: Record<string, string>): string => {
+    return url
+      .replace(/{(\\w+)}/g, (_, key: string) => params[key] || \`{\${key}}\`)
+      .replace(/:([a-zA-Z0-9_]+)/g, (_, key: string) => params[key] || \`:\${key}\`);
+  }
+
+  /** Uses URLSearchParams, skips null/undefined values */
+  defaultEncodeSearchParams = (queryParams: Record<string, unknown> | undefined): URLSearchParams | undefined => {
+    if (!queryParams) return;
+
+    const searchParams = new URLSearchParams();
+    Object.entries(queryParams).forEach(([key, value]) => {
+      if (value != null) {
+        // Skip null/undefined values
+        if (Array.isArray(value)) {
+          value.forEach((val) => val != null && searchParams.append(key, String(val)));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      }
+    });
+
+    return searchParams;
+  }
+
+  defaultParseResponseData = async (response: Response): Promise<unknown> => {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.startsWith("text/")) {
+      return (await response.text())
+    }
+
+    if (contentType === "application/octet-stream") {
+      return (await response.arrayBuffer())
     }
-    return response.text() as unknown as T;
+
+    if (
+      contentType.includes("application/json") ||
+      (contentType.includes("application/") && contentType.includes("json")) ||
+      contentType === "*/*"
+      ) {
+      try {
+        return await response.json();
+      } catch {
+        return undefined
+      }
+    }
+
+    return
   }
 
   ${Object.entries(byMethods)
     .map(([method, endpointByMethod]) => {
       const capitalizedMethod = capitalize(method);
-      const infer = inferByRuntime[ctx.runtime];
 
       return endpointByMethod.length
         ? `// <ApiClient.${method}>
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
-      ...params: MaybeOptionalArg<${match(ctx.runtime)
-        .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
-        .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
-        .otherwise(() => `TEndpoint["parameters"]`)} & { withResponse?: false; throwOnStatusError?: boolean }>
-    ): Promise<${match(ctx.runtime)
-      .with("zod", "yup", () => infer(`InferResponseByStatus<TEndpoint, SuccessStatusCode>`))
-      .with(
-        "arktype",
-        "io-ts",
-        "typebox",
-        "valibot",
-        () => `InferResponseByStatus<${infer(`TEndpoint`)}, SuccessStatusCode>["data"]`,
-      )
-      .otherwise(() => `Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]`)}>;
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean })
+      >
+    ): Promise<Extract<InferResponseByStatus<${InferTEndpoint}, SuccessStatusCode>, { data: {} }>["data"]>;
 
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
-      ...params: MaybeOptionalArg<${match(ctx.runtime)
-        .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
-        .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
-        .otherwise(() => `TEndpoint["parameters"]`)} & { withResponse: true; throwOnStatusError?: boolean }>
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean })
+      >
     ): Promise<SafeApiResponse<TEndpoint>>;
 
-    ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
+    ${method}<Path extends keyof ${capitalizedMethod}Endpoints, _TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
       ...params: MaybeOptionalArg<any>
     ): Promise<any> {
-      const requestParams = params[0];
-      const withResponse = requestParams?.withResponse;
-      const { withResponse: _, throwOnStatusError = withResponse ? false : true, ...fetchParams } = requestParams || {};
-
-      const promise = this.fetcher("${method}", this.baseUrl + path, Object.keys(fetchParams).length ? requestParams : undefined)
-        .then(async (response) => {
-          const data = await this.parseResponse(response);
-          const typedResponse = Object.assign(response, {
-            data: data,
-            json: () => Promise.resolve(data)
-          }) as SafeApiResponse<TEndpoint>;
-
-          if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
-            throw new TypedResponseError(typedResponse as never);
-          }
-
-          return withResponse ? typedResponse : data;
-        });
-
-        return promise ${match(ctx.runtime)
-          .with("zod", "yup", () => `as Promise<${infer(`InferResponseByStatus<TEndpoint, SuccessStatusCode>`)}>`)
-          .with(
-            "arktype",
-            "io-ts",
-            "typebox",
-            "valibot",
-            () => `as Promise<InferResponseByStatus<${infer(`TEndpoint`)}, SuccessStatusCode>["data"]>`,
-          )
-          .otherwise(() => `as Promise<Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]>`)}
+        return this.request("${method}", path, ...params);
     }
     // </ApiClient.${method}>
     `
@@ -523,20 +551,74 @@ export class ApiClient {
     >(
       method: TMethod,
       path: TPath,
-      ...params: MaybeOptionalArg<${match(ctx.runtime)
-        .with("zod", "yup", () =>
-          inferByRuntime[ctx.runtime](`TEndpoint extends { parameters: infer Params } ? Params : never`),
-        )
-        .with(
-          "arktype",
-          "io-ts",
-          "typebox",
-          "valibot",
-          () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`,
-        )
-        .otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
-    : Promise<SafeApiResponse<TEndpoint>> {
-      return this.fetcher(method, this.baseUrl + (path as string), params[0] as EndpointParameters) as Promise<SafeApiResponse<TEndpoint>>;
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: false; throwOnStatusError?: boolean })
+      >
+    ): Promise<Extract<InferResponseByStatus<${InferTEndpoint}, SuccessStatusCode>, { data: {} }>["data"]>
+
+    request<
+      TMethod extends keyof EndpointByMethod,
+      TPath extends keyof EndpointByMethod[TMethod],
+      TEndpoint extends EndpointByMethod[TMethod][TPath]
+    >(
+      method: TMethod,
+      path: TPath,
+      ...params: MaybeOptionalArg<
+        (TEndpoint extends { parameters: infer UParams }
+          ? NotNever<UParams> extends true ? UParams & { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean } : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean }
+          : { overrides?: RequestInit; withResponse?: true; throwOnStatusError?: boolean })
+      >
+    ): Promise<SafeApiResponse<TEndpoint>>;
+
+    request<
+      TMethod extends keyof EndpointByMethod,
+      TPath extends keyof EndpointByMethod[TMethod],
+      TEndpoint extends EndpointByMethod[TMethod][TPath]
+    >(
+      method: TMethod,
+      path: TPath,
+      ...params: MaybeOptionalArg<any>
+    ): Promise<any> {
+      const requestParams = params[0];
+      const withResponse = requestParams?.withResponse;
+      const { withResponse: _, throwOnStatusError = withResponse ? false : true, overrides, ...fetchParams } = requestParams || {};
+
+      const parametersToSend: EndpointParameters = {};
+      if (requestParams?.body !== undefined) (parametersToSend as any).body = requestParams.body;
+      if (requestParams?.query !== undefined) (parametersToSend as any).query = requestParams.query;
+      if (requestParams?.header !== undefined) (parametersToSend as any).header = requestParams.header;
+      if (requestParams?.path !== undefined) (parametersToSend as any).path = requestParams.path;
+
+      const resolvedPath = (this.fetcher.decodePathParams ?? this.defaultDecodePathParams)(this.baseUrl + (path as string), (parametersToSend.path ?? {}) as Record<string, string>);
+      const url = new URL(resolvedPath);
+      const urlSearchParams = (this.fetcher.encodeSearchParams ?? this.defaultEncodeSearchParams)(parametersToSend.query);
+
+      const promise = this.fetcher.fetch({
+        method: method,
+        path: (path as string),
+        url,
+        urlSearchParams,
+        parameters: Object.keys(fetchParams).length ? fetchParams : undefined,
+        overrides,
+        throwOnStatusError
+      })
+        .then(async (response) => {
+          const data = await (this.fetcher.parseResponseData ?? this.defaultParseResponseData)(response);
+          const typedResponse = Object.assign(response, {
+            data: data,
+            json: () => Promise.resolve(data)
+          }) as SafeApiResponse<TEndpoint>;
+
+          if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
+            throw new TypedResponseError(typedResponse as never);
+          }
+
+          return withResponse ? typedResponse : data;
+        });
+
+        return promise as Extract<InferResponseByStatus<${InferTEndpoint}, SuccessStatusCode>, { data: {} }>["data"]
     }
     // </ApiClient.request>
 }

package/src/map-openapi-endpoints.ts

@@ -6,7 +6,14 @@ import { createBoxFactory } from "./box-factory.ts";
 import { openApiSchemaToTs } from "./openapi-schema-to-ts.ts";
 import { createRefResolver } from "./ref-resolver.ts";
 import { tsFactory } from "./ts-factory.ts";
-import { AnyBox, BoxRef, OpenapiSchemaConvertContext, type BoxObject, type LibSchemaObject } from "./types.ts";
+import {
+  AnyBox,
+  BoxRef,
+  OpenapiSchemaConvertContext,
+  type BoxObject,
+  type BoxUnion,
+  type LibSchemaObject,
+} from "./types.ts";
 import { pathToVariableName } from "./string-utils.ts";
 import { NameTransformOptions } from "./types.ts";
 import { match, P } from "ts-pattern";
@@ -134,7 +141,7 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject, options?: { nameTransfor
       }
 
       const allResponses: Record<string, AnyBox> = {};
-      const allHeaders: Record<string, Box<BoxObject>> = {};
+      const allResponseHeaders: Record<string, Box<BoxObject>> = {};
 
       Object.entries(operation.responses ?? {}).map(([status, responseOrRef]) => {
         const responseObj = refs.unwrap<ResponseObject>(responseOrRef);
@@ -146,14 +153,26 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject, options?: { nameTransfor
           mediaTypes.forEach((mediaType) => {
             // If no JSON content, use unknown type
             const schema = content[mediaType] ? (content[mediaType].schema ?? {}) : {};
-            const t = createBoxFactory(schema as LibSchemaObject, ctx);
             const mediaTypeResponse = openApiSchemaToTs({ schema, ctx });
 
             if (allResponses[status]) {
+              const t = createBoxFactory(
+                {
+                  oneOf: [
+                    ...((allResponses[status].schema as LibSchemaObject).oneOf
+                      ? (allResponses[status].schema as LibSchemaObject).oneOf!
+                      : [allResponses[status].schema]),
+                    schema,
+                  ],
+                } as LibSchemaObject,
+                ctx,
+              );
               allResponses[status] = t.union([
-                ...(Array.isArray(allResponses[status]) ? allResponses[status] : [allResponses[status]]),
+                ...(allResponses[status].type === "union"
+                  ? (allResponses[status] as Box<BoxUnion>).params.types
+                  : [allResponses[status]]),
                 mediaTypeResponse,
-              ]);
+              ] as Box[]);
             } else {
               allResponses[status] = mediaTypeResponse;
             }
@@ -162,13 +181,25 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject, options?: { nameTransfor
           // If no content defined, use unknown type
           const schema = {};
           const unknown = openApiSchemaToTs({ schema: {}, ctx });
-          const t = createBoxFactory(schema as LibSchemaObject, ctx);
 
           if (allResponses[status]) {
+            const t = createBoxFactory(
+              {
+                oneOf: [
+                  ...((allResponses[status].schema as LibSchemaObject).oneOf
+                    ? (allResponses[status].schema as LibSchemaObject).oneOf!
+                    : [allResponses[status].schema]),
+                  schema,
+                ],
+              } as LibSchemaObject,
+              ctx,
+            );
             allResponses[status] = t.union([
-              ...(Array.isArray(allResponses[status]) ? allResponses[status] : [allResponses[status]]),
+              ...(allResponses[status].type === "union"
+                ? (allResponses[status] as Box<BoxUnion>).params.types
+                : [allResponses[status]]),
               unknown,
-            ]);
+            ] as Box[]);
           } else {
             allResponses[status] = unknown;
           }
@@ -193,7 +224,7 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject, options?: { nameTransfor
           );
 
           if (Object.keys(mappedHeaders).length) {
-            allHeaders[status] = t.object(mappedHeaders);
+            allResponseHeaders[status] = t.object(mappedHeaders);
           }
         }
       });
@@ -203,8 +234,8 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject, options?: { nameTransfor
         endpoint.responses = allResponses;
       }
 
-      if (Object.keys(allHeaders).length) {
-        endpoint.responseHeaders = allHeaders;
+      if (Object.keys(allResponseHeaders).length) {
+        endpoint.responseHeaders = allResponseHeaders;
       }
 
       endpointList.push(endpoint);

package/src/tanstack-query.generator.ts

@@ -76,7 +76,10 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
         .map(
           (method) => `
         // <ApiClient.${method}>
-        ${method}<Path extends keyof ${capitalize(method)}Endpoints, TEndpoint extends ${capitalize(method)}Endpoints[Path]>(
+        ${method}<
+            Path extends keyof ${capitalize(method)}Endpoints,
+            TEndpoint extends ${capitalize(method)}Endpoints[Path]
+        >(
             path: Path,
             ...params: MaybeOptionalArg<TEndpoint["parameters"]>
         ) {
@@ -91,28 +94,14 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
                         const requestParams = {
                             ...(params[0] || {}),
                             ...(queryKey[0] || {}),
-                            signal,
+                            overrides: { signal },
                             withResponse: false as const
                         };
-                        const res = await this.client.${method}(path, requestParams);
+                        const res = await this.client.${method}(path, requestParams as never);
                         return res as Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"];
                     },
                     queryKey: queryKey
                 }),
-                mutationFn: {} as "You need to pass .mutationOptions to the useMutation hook",
-                mutationOptions: {
-                    mutationKey: queryKey,
-                    mutationFn: async (localOptions: TEndpoint extends { parameters: infer Parameters} ? Parameters: never) => {
-                        const requestParams = {
-                            ...(params[0] || {}),
-                            ...(queryKey[0] || {}),
-                            ...(localOptions || {}),
-                            withResponse: false as const
-                        };
-                        const res = await this.client.${method}(path, requestParams);
-                        return res as Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"];
-                    }
-                }
             };
 
             return query
@@ -147,40 +136,54 @@ export const generateTanstackQueryFile = async (ctx: GeneratorContext & { relati
                 : Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]
             ) => TSelection;
              throwOnStatusError?: boolean
+             throwOnError?: boolean | ((error: TError) => boolean)
         }) {
             const mutationKey = [{ method, path }] as const;
+            const mutationFn = async <TLocalWithResponse extends boolean = TWithResponse, TLocalSelection = TLocalWithResponse extends true
+                ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
+                : Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]>
+            (params: (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
+                withResponse?: TLocalWithResponse;
+                throwOnStatusError?: boolean;
+                overrides?: RequestInit;
+            }): Promise<TLocalSelection> => {
+                const withResponse = params.withResponse ??options?.withResponse ?? false;
+                const throwOnStatusError = params.throwOnStatusError ?? options?.throwOnStatusError ?? (withResponse ? false : true);
+                const selectFn = options?.selectFn;
+                const response = await (this.client as any)[method](path, {
+                    ...params as any,
+                    withResponse: true,
+                    throwOnStatusError: false,
+                });
+
+                if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
+                    throw new TypedResponseError(response as never);
+                }
+
+                // Return just the data if withResponse is false, otherwise return the full response
+                const finalResponse = withResponse ? response : response.data;
+                const res = selectFn ? selectFn(finalResponse as any) : finalResponse;
+                return res as never;
+            };
             return {
             /** type-only property if you need easy access to the endpoint params */
             "~endpoint": {} as TEndpoint,
             mutationKey: mutationKey,
             mutationFn: {} as "You need to pass .mutationOptions to the useMutation hook",
             mutationOptions: {
+                throwOnError: options?.throwOnError as boolean | ((error: TError) => boolean),
                 mutationKey: mutationKey,
-                mutationFn: async <TLocalWithResponse extends boolean = TWithResponse, TLocalSelection = TLocalWithResponse extends true
-                    ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
-                    : Extract<InferResponseByStatus<TEndpoint, SuccessStatusCode>, { data: {} }>["data"]>
-                (params: (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
-                    withResponse?: TLocalWithResponse;
-                    throwOnStatusError?: boolean;
-                }): Promise<TLocalSelection> => {
-                    const withResponse = params.withResponse ??options?.withResponse ?? false;
-                    const throwOnStatusError = params.throwOnStatusError ?? options?.throwOnStatusError ?? (withResponse ? false : true);
-                    const selectFn = options?.selectFn;
-                    const response = await (this.client as any)[method](path, { ...params as any, withResponse: true, throwOnStatusError: false });
-
-                    if (throwOnStatusError && errorStatusCodes.includes(response.status as never)) {
-                        throw new TypedResponseError(response as never);
-                    }
-
-                    // Return just the data if withResponse is false, otherwise return the full response
-                    const finalResponse = withResponse ? response : response.data;
-                    const res = selectFn ? selectFn(finalResponse as any) : finalResponse;
-                    return res as never;
+                mutationFn: mutationFn,
+            } as Omit<import("@tanstack/react-query").UseMutationOptions<
+                TSelection,
+                TError,
+                (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
+                withResponse?: boolean;
+                throwOnStatusError?: boolean;
                 }
-            } satisfies import("@tanstack/react-query").UseMutationOptions<TSelection, TError, (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
-                    withResponse?: boolean;
-                    throwOnStatusError?: boolean;
-                }>,
+            >, "mutationFn"> & {
+                mutationFn: typeof mutationFn
+            },
         }
     }
         // </ApiClient.request>