typed-openapi 1.5.1 → 2.0.0

package/dist/{chunk-OVT6OLBK.js → chunk-E6A7N4ND.js}

@@ -282,6 +282,69 @@ import { capitalize as capitalize2, groupBy } from "pastable/server";
 import * as Codegen from "@sinclair/typebox-codegen";
 import { match } from "ts-pattern";
 import { type } from "arktype";
+var DEFAULT_SUCCESS_STATUS_CODES = [
+  200,
+  201,
+  202,
+  203,
+  204,
+  205,
+  206,
+  207,
+  208,
+  226,
+  300,
+  301,
+  302,
+  303,
+  304,
+  305,
+  306,
+  307,
+  308
+];
+var DEFAULT_ERROR_STATUS_CODES = [
+  400,
+  401,
+  402,
+  403,
+  404,
+  405,
+  406,
+  407,
+  408,
+  409,
+  410,
+  411,
+  412,
+  413,
+  414,
+  415,
+  416,
+  417,
+  418,
+  421,
+  422,
+  423,
+  424,
+  425,
+  426,
+  428,
+  429,
+  431,
+  451,
+  500,
+  501,
+  502,
+  503,
+  504,
+  505,
+  506,
+  507,
+  508,
+  510,
+  511
+];
 var allowedRuntimes = type("'none' | 'arktype' | 'io-ts' | 'typebox' | 'valibot' | 'yup' | 'zod'");
 var runtimeValidationGenerator = {
   arktype: Codegen.ModelToArkType.Generate,
@@ -314,10 +377,17 @@ var replacerByRuntime = {
   )
 };
 var generateFile = (options) => {
-  const ctx = { ...options, runtime: options.runtime ?? "none" };
+  const ctx = {
+    ...options,
+    runtime: options.runtime ?? "none",
+    successStatusCodes: options.successStatusCodes ?? DEFAULT_SUCCESS_STATUS_CODES,
+    errorStatusCodes: options.errorStatusCodes ?? DEFAULT_ERROR_STATUS_CODES,
+    includeClient: options.includeClient ?? true
+  };
   const schemaList = generateSchemaList(ctx);
   const endpointSchemaList = options.schemasOnly ? "" : generateEndpointSchemaList(ctx);
-  const apiClient = options.schemasOnly ? "" : generateApiClient(ctx);
+  const endpointByMethod = options.schemasOnly ? "" : generateEndpointByMethod(ctx);
+  const apiClient = options.schemasOnly || !ctx.includeClient ? "" : generateApiClient(ctx);
   const transform = ctx.runtime === "none" ? (file2) => file2 : (file2) => {
     const model = Codegen.TypeScriptToModel.Generate(file2);
     const transformer = runtimeValidationGenerator[ctx.runtime];
@@ -337,6 +407,7 @@ var generateFile = (options) => {
   };
   const file = `
   ${transform(schemaList + endpointSchemaList)}
+  ${endpointByMethod}
   ${apiClient}
   `;
   return file;
@@ -380,6 +451,20 @@ var responseHeadersObjectToString = (responseHeaders, ctx) => {
   }
   return str + "}";
 };
+var generateResponsesObject = (responses, ctx) => {
+  let str = "{";
+  for (const [statusCode, responseType] of Object.entries(responses)) {
+    const value = ctx.runtime === "none" ? responseType.recompute((box) => {
+      if (Box.isReference(box) && !box.params.generics && box.value !== "null") {
+        box.value = `Schemas.${box.value}`;
+      }
+      return box;
+    }).value : responseType.value;
+    str += `${wrapWithQuotesIfNeeded(statusCode)}: ${value},
+`;
+  }
+  return str + "}";
+};
 var generateEndpointSchemaList = (ctx) => {
   let file = `
   ${ctx.runtime === "none" ? "export namespace Endpoints {" : ""}
@@ -411,6 +496,7 @@ var generateEndpointSchemaList = (ctx) => {
       }
       return box;
     }).value : endpoint.response.value},
+      ${endpoint.responses ? `responses: ${generateResponsesObject(endpoint.responses, ctx)},` : ""}
       ${endpoint.responseHeaders ? `responseHeaders: ${responseHeadersObjectToString(endpoint.responseHeaders, ctx)},` : ""}
     }
 `;
@@ -431,7 +517,7 @@ var generateEndpointByMethod = (ctx) => {
     return `${method}: {
            ${list.map(
       (endpoint) => `"${endpoint.path}": ${ctx.runtime === "none" ? "Endpoints." : ""}${endpoint.meta.alias}`
-    )}
+    ).join(",\n")}
          }`;
   }).join(",\n")}
      }
@@ -447,9 +533,11 @@ var generateEndpointByMethod = (ctx) => {
   return endpointByMethod + shorthands;
 };
 var generateApiClient = (ctx) => {
+  if (!ctx.includeClient) {
+    return "";
+  }
   const { endpointList } = ctx;
   const byMethods = groupBy(endpointList, "method");
-  const endpointSchemaList = generateEndpointByMethod(ctx);
   const apiClientTypes = `
 // <ApiClientTypes>
 export type EndpointParameters = {
@@ -467,6 +555,7 @@ type RequestFormat = "json" | "form-data" | "form-url" | "binary" | "text";
 export type DefaultEndpoint = {
   parameters?: EndpointParameters | undefined;
   response: unknown;
+  responses?: Record<string, unknown>;
   responseHeaders?: Record<string, unknown>;
 };
 
@@ -482,11 +571,64 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
     areParametersRequired: boolean;
   };
   response: TConfig["response"];
+  responses?: TConfig["responses"];
   responseHeaders?: TConfig["responseHeaders"]
 };
 
 export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
 
+export const successStatusCodes = [${ctx.successStatusCodes.join(",")}] as const;
+export type SuccessStatusCode = typeof successStatusCodes[number];
+
+export const errorStatusCodes = [${ctx.errorStatusCodes.join(",")}] as const;
+export type ErrorStatusCode = typeof errorStatusCodes[number];
+
+// Error handling types
+/** @see https://developer.mozilla.org/en-US/docs/Web/API/Response */
+interface SuccessResponse<TSuccess, TStatusCode> extends Omit<Response, "ok" | "status" | "json"> {
+  ok: true;
+  status: TStatusCode;
+  data: TSuccess;
+  /** [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Response/json) */
+  json: () => Promise<TSuccess>;
+}
+
+/** @see https://developer.mozilla.org/en-US/docs/Web/API/Response */
+interface ErrorResponse<TData, TStatusCode> extends Omit<Response, "ok" | "status" | "json"> {
+  ok: false;
+  status: TStatusCode;
+  data: TData;
+  /** [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/API/Response/json) */
+  json: () => Promise<TData>;
+}
+
+export type TypedApiResponse<TSuccess, TAllResponses extends Record<string | number, unknown> = {}> =
+  (keyof TAllResponses extends never
+    ? SuccessResponse<TSuccess, number>
+    : {
+        [K in keyof TAllResponses]: K extends string
+          ? K extends \`\${infer TStatusCode extends number}\`
+            ? TStatusCode extends SuccessStatusCode
+              ? SuccessResponse<TSuccess, TStatusCode>
+              : ErrorResponse<TAllResponses[K], TStatusCode>
+            : never
+          : K extends number
+            ? K extends SuccessStatusCode
+              ? SuccessResponse<TSuccess, K>
+              : ErrorResponse<TAllResponses[K], K>
+            : never;
+      }[keyof TAllResponses]);
+
+export type SafeApiResponse<TEndpoint> = TEndpoint extends { response: infer TSuccess; responses: infer TResponses }
+  ? TResponses extends Record<string, unknown>
+    ? TypedApiResponse<TSuccess, TResponses>
+    : SuccessResponse<TSuccess, number>
+  : TEndpoint extends { response: infer TSuccess }
+    ? SuccessResponse<TSuccess, number>
+    : never;
+
+export type InferResponseByStatus<TEndpoint, TStatusCode> = Extract<SafeApiResponse<TEndpoint>, { status: TStatusCode }>
+
 type RequiredKeys<T> = {
   [P in keyof T]-?: undefined extends T[P] ? never : P;
 }[keyof T];
@@ -496,9 +638,23 @@ type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [confi
 // </ApiClientTypes>
 `;
   const apiClient = `
+// <TypedResponseError>
+export class TypedResponseError extends Error {
+  response: ErrorResponse<unknown, ErrorStatusCode>;
+  status: number;
+  constructor(response: ErrorResponse<unknown, ErrorStatusCode>) {
+    super(\`HTTP \${response.status}: \${response.statusText}\`);
+    this.name = 'TypedResponseError';
+    this.response = response;
+    this.status = response.status;
+  }
+}
+// </TypedResponseError>
 // <ApiClient>
 export class ApiClient {
   baseUrl: string = "";
+  successStatusCodes = successStatusCodes;
+  errorStatusCodes = errorStatusCodes;
 
   constructor(public fetcher: Fetcher) {}
 
@@ -521,10 +677,44 @@ export class ApiClient {
     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"]`)}>
-    ): Promise<${match(ctx.runtime).with("zod", "yup", () => infer(`TEndpoint["response"]`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["response"]`).otherwise(() => `TEndpoint["response"]`)}> {
-      return this.fetcher("${method}", this.baseUrl + path, params[0])
-          .then(response => this.parseResponse(response))${match(ctx.runtime).with("zod", "yup", () => `as Promise<${infer(`TEndpoint["response"]`)}>`).with("arktype", "io-ts", "typebox", "valibot", () => `as Promise<${infer(`TEndpoint`) + `["response"]`}>`).otherwise(() => `as Promise<TEndpoint["response"]>`)};
+      ...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(`TEndpoint["response"]`)).with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["response"]`).otherwise(() => `TEndpoint["response"]`)}>;
+
+    ${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 }>
+    ): Promise<SafeApiResponse<TEndpoint>>;
+
+    ${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(`TEndpoint["response"]`)}>`).with(
+      "arktype",
+      "io-ts",
+      "typebox",
+      "valibot",
+      () => `as Promise<${infer(`TEndpoint`) + `["response"]`}>`
+    ).otherwise(() => `as Promise<TEndpoint["response"]>`)}
     }
     // </ApiClient.${method}>
     ` : "";
@@ -552,11 +742,8 @@ export class ApiClient {
     "valibot",
     () => inferByRuntime[ctx.runtime](`TEndpoint`) + `["parameters"]`
   ).otherwise(() => `TEndpoint extends { parameters: infer Params } ? Params : never`)}>)
-    : Promise<Omit<Response, "json"> & {
-      /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
-      json: () => Promise<TEndpoint extends { response: infer Res } ? Res : never>;
-    }> {
-      return this.fetcher(method, this.baseUrl + (path as string), params[0] as EndpointParameters);
+    : Promise<SafeApiResponse<TEndpoint>> {
+      return this.fetcher(method, this.baseUrl + (path as string), params[0] as EndpointParameters) as Promise<SafeApiResponse<TEndpoint>>;
     }
     // </ApiClient.request>
 }
@@ -574,11 +761,26 @@ export function createApiClient(fetcher: Fetcher, baseUrl?: string) {
  api.get("/users").then((users) => console.log(users));
  api.post("/users", { body: { name: "John" } }).then((user) => console.log(user));
  api.put("/users/:id", { path: { id: 1 }, body: { name: "John" } }).then((user) => console.log(user));
+
+ // With error handling
+ const result = await api.get("/users/{id}", { path: { id: "123" }, withResponse: true });
+ if (result.ok) {
+   // Access data directly
+   const user = result.data;
+   console.log(user);
+
+   // Or use the json() method for compatibility
+   const userFromJson = await result.json();
+   console.log(userFromJson);
+ } else {
+   const error = result.data;
+   console.error(\`Error \${result.status}:\`, error);
+ }
 */
 
-// </ApiClient
+// </ApiClient>
 `;
-  return endpointSchemaList + apiClientTypes + apiClient;
+  return apiClientTypes + apiClient;
 };
 
 // src/ref-resolver.ts
@@ -944,14 +1146,45 @@ var mapOpenApiEndpoints = (doc, options) => {
         endpoint.parameters = Object.keys(params).length ? params : void 0;
       }
       let responseObject;
+      const allResponses = {};
       Object.entries(operation.responses ?? {}).map(([status, responseOrRef]) => {
         const statusCode = Number(status);
-        if (statusCode >= 200 && statusCode < 300) {
-          responseObject = refs.unwrap(responseOrRef);
+        const responseObj = refs.unwrap(responseOrRef);
+        const content2 = responseObj?.content;
+        if (content2) {
+          const matchingMediaType = Object.keys(content2).find(isResponseMediaType);
+          if (matchingMediaType && content2[matchingMediaType]) {
+            allResponses[status] = openApiSchemaToTs({
+              schema: content2[matchingMediaType]?.schema ?? {},
+              ctx
+            });
+          } else {
+            allResponses[status] = openApiSchemaToTs({ schema: {}, ctx });
+          }
+        } else {
+          allResponses[status] = openApiSchemaToTs({ schema: {}, ctx });
+        }
+        if (statusCode >= 200 && statusCode < 300 && !responseObject) {
+          responseObject = responseObj;
         }
       });
       if (!responseObject && operation.responses?.default) {
         responseObject = refs.unwrap(operation.responses.default);
+        if (!allResponses["default"]) {
+          const content2 = responseObject?.content;
+          if (content2) {
+            const matchingMediaType = Object.keys(content2).find(isResponseMediaType);
+            if (matchingMediaType && content2[matchingMediaType]) {
+              allResponses["default"] = openApiSchemaToTs({
+                schema: content2[matchingMediaType]?.schema ?? {},
+                ctx
+              });
+            }
+          }
+        }
+      }
+      if (Object.keys(allResponses).length > 0) {
+        endpoint.responses = allResponses;
       }
       const content = responseObject?.content;
       if (content) {
@@ -998,7 +1231,8 @@ var generateTanstackQueryFile = async (ctx) => {
   const endpointMethods = new Set(ctx.endpointList.map((endpoint) => endpoint.method.toLowerCase()));
   const file = `
   import { queryOptions } from "@tanstack/react-query"
-  import type { EndpointByMethod, ApiClient } from "${ctx.relativeApiClientPath}"
+  import type { EndpointByMethod, ApiClient, SuccessStatusCode, ErrorStatusCode, InferResponseByStatus } from "${ctx.relativeApiClientPath}"
+  import { errorStatusCodes, TypedResponseError } from "${ctx.relativeApiClientPath}"
 
   type EndpointQueryKey<TOptions extends EndpointParameters> = [
       TOptions & {
@@ -1062,30 +1296,36 @@ var generateTanstackQueryFile = async (ctx) => {
             path: Path,
             ...params: MaybeOptionalArg<TEndpoint["parameters"]>
         ) {
-            const queryKey = createQueryKey(path, params[0]);
+            const queryKey = createQueryKey(path as string, params[0]);
             const query = {
                 /** type-only property if you need easy access to the endpoint params */
                 "~endpoint": {} as TEndpoint,
                 queryKey,
+                queryFn: {} as "You need to pass .queryOptions to the useQuery hook",
                 queryOptions: queryOptions({
                     queryFn: async ({ queryKey, signal, }) => {
-                        const res = await this.client.${method}(path, {
-                            ...params,
-                            ...queryKey[0],
+                        const requestParams = {
+                            ...(params[0] || {}),
+                            ...(queryKey[0] || {}),
                             signal,
-                        });
+                            withResponse: false as const
+                        };
+                        const res = await this.client.${method}(path, requestParams);
                         return res as TEndpoint["response"];
                     },
                     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 res = await this.client.${method}(path, {
-                            ...params,
-                            ...queryKey[0],
-                            ...localOptions,
-                        });
+                        const requestParams = {
+                            ...(params[0] || {}),
+                            ...(queryKey[0] || {}),
+                            ...(localOptions || {}),
+                            withResponse: false as const
+                        };
+                        const res = await this.client.${method}(path, requestParams);
                         return res as TEndpoint["response"];
                     }
                 }
@@ -1099,32 +1339,67 @@ var generateTanstackQueryFile = async (ctx) => {
 
         // <ApiClient.request>
         /**
-         * Generic mutation method with full type-safety for any endpoint that doesnt require parameters to be passed initially
+         * Generic mutation method with full type-safety for any endpoint; it doesnt require parameters to be passed initially
+         * but instead will require them to be passed when calling the mutation.mutate() method
          */
         mutation<
             TMethod extends keyof EndpointByMethod,
             TPath extends keyof EndpointByMethod[TMethod],
             TEndpoint extends EndpointByMethod[TMethod][TPath],
-            TSelection,
-        >(method: TMethod, path: TPath, selectFn?: (res: Omit<Response, "json"> & {
-            /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */
-            json: () => Promise<TEndpoint extends { response: infer Res } ? Res : never>;
-        }) => TSelection) {
+            TWithResponse extends boolean = false,
+            TSelection = TWithResponse extends true
+                ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
+                : TEndpoint extends { response: infer Res } ? Res : never,
+            TError = TEndpoint extends { responses: infer TResponses }
+                ? TResponses extends Record<string | number, unknown>
+                    ? InferResponseByStatus<TEndpoint, ErrorStatusCode>
+                    : Error
+                : Error
+        >(method: TMethod, path: TPath, options?: {
+            withResponse?: TWithResponse;
+            selectFn?: (res: TWithResponse extends true
+                ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
+                : TEndpoint extends { response: infer Res } ? Res : never
+            ) => TSelection;
+             throwOnStatusError?: boolean
+        }) {
             const mutationKey = [{ method, path }] as const;
             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: {
                 mutationKey: mutationKey,
-                mutationFn: async (params: TEndpoint extends { parameters: infer Parameters } ? Parameters : never) => {
-                const response = await this.client.request(method, path, params);
-                const res = selectFn ? selectFn(response) : response
-                return res as unknown extends TSelection ? typeof response : Awaited<TSelection>
-                },
-            },
-            };
+                mutationFn: async <TLocalWithResponse extends boolean = TWithResponse, TLocalSelection = TLocalWithResponse extends true
+                    ? InferResponseByStatus<TEndpoint, SuccessStatusCode>
+                    : TEndpoint extends { response: infer Res }
+                        ? Res
+                        : never>
+                (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;
+                }
+            } satisfies import("@tanstack/react-query").UseMutationOptions<TSelection, TError, (TEndpoint extends { parameters: infer Parameters } ? Parameters : {}) & {
+                    withResponse?: boolean;
+                    throwOnStatusError?: boolean;
+                }>,
         }
+    }
         // </ApiClient.request>
   }
 `;
@@ -1136,6 +1411,8 @@ export {
   createFactory,
   createBoxFactory,
   openApiSchemaToTs,
+  DEFAULT_SUCCESS_STATUS_CODES,
+  DEFAULT_ERROR_STATUS_CODES,
   allowedRuntimes,
   generateFile,
   createRefResolver,

package/dist/{chunk-O7DZWQK4.js → chunk-MCVYB63W.js}

@@ -1,9 +1,11 @@
 import {
+  DEFAULT_ERROR_STATUS_CODES,
+  DEFAULT_SUCCESS_STATUS_CODES,
   allowedRuntimes,
   generateFile,
   generateTanstackQueryFile,
   mapOpenApiEndpoints
-} from "./chunk-OVT6OLBK.js";
+} from "./chunk-E6A7N4ND.js";
 import {
   prettify
 } from "./chunk-KAEXXJ7X.js";
@@ -26,20 +28,28 @@ var optionsSchema = type({
   "output?": "string",
   runtime: allowedRuntimes,
   tanstack: "boolean | string",
-  schemasOnly: "boolean"
+  schemasOnly: "boolean",
+  "includeClient?": "boolean | 'true' | 'false'",
+  "successStatusCodes?": "string",
+  "errorStatusCodes?": "string"
 });
 async function generateClientFiles(input, options) {
   const openApiDoc = await SwaggerParser.bundle(input);
   const ctx = mapOpenApiEndpoints(openApiDoc, options);
   console.log(`Found ${ctx.endpointList.length} endpoints`);
-  const content = await prettify(
-    generateFile({
-      ...ctx,
-      runtime: options.runtime,
-      schemasOnly: options.schemasOnly,
-      nameTransform: options.nameTransform
-    })
-  );
+  const successStatusCodes = options.successStatusCodes ? options.successStatusCodes.split(",").map((code) => parseInt(code.trim(), 10)) : void 0;
+  const errorStatusCodes = options.errorStatusCodes ? options.errorStatusCodes.split(",").map((code) => parseInt(code.trim(), 10)) : void 0;
+  const includeClient = options.includeClient === "false" ? false : options.includeClient === "true" ? true : options.includeClient;
+  const generatorOptions = {
+    ...ctx,
+    runtime: options.runtime,
+    schemasOnly: options.schemasOnly,
+    nameTransform: options.nameTransform,
+    includeClient: includeClient ?? true,
+    successStatusCodes: successStatusCodes ?? DEFAULT_SUCCESS_STATUS_CODES,
+    errorStatusCodes: errorStatusCodes ?? DEFAULT_ERROR_STATUS_CODES
+  };
+  const content = await prettify(generateFile(generatorOptions));
   const outputPath = join(
     cwd,
     options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`
@@ -49,7 +59,7 @@ async function generateClientFiles(input, options) {
   await writeFile(outputPath, content);
   if (options.tanstack) {
     const tanstackContent = await generateTanstackQueryFile({
-      ...ctx,
+      ...generatorOptions,
       relativeApiClientPath: "./" + basename(outputPath)
     });
     const tanstackOutputPath = join(

package/dist/cli.js

@@ -1,9 +1,9 @@
 import {
   generateClientFiles
-} from "./chunk-O7DZWQK4.js";
+} from "./chunk-MCVYB63W.js";
 import {
   allowedRuntimes
-} from "./chunk-OVT6OLBK.js";
+} from "./chunk-E6A7N4ND.js";
 import "./chunk-KAEXXJ7X.js";
 
 // src/cli.ts
@@ -12,10 +12,13 @@ import { readFileSync } from "fs";
 var { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 var cli = cac(name);
 cli.command("<input>", "Generate").option("-o, --output <path>", "Output path for the api client ts file (defaults to `<input>.<runtime>.ts`)").option(
-  "-r, --runtime <name>",
+  "-r, --runtime <n>",
   `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.toString()}`,
   { default: "none" }
-).option("--schemas-only", "Only generate schemas, skipping client generation (defaults to false)", { default: false }).option(
+).option("--schemas-only", "Only generate schemas, skipping client generation (defaults to false)", { default: false }).option("--include-client", "Include API client types and implementation (defaults to true)", { default: true }).option(
+  "--success-status-codes <codes>",
+  "Comma-separated list of success status codes (defaults to 2xx and 3xx ranges)"
+).option("--error-status-codes <codes>", "Comma-separated list of error status codes (defaults to 4xx and 5xx ranges)").option(
   "--tanstack [name]",
   "Generate tanstack client, defaults to false, can optionally specify a name for the generated file"
 ).action(async (input, _options) => {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { ReferenceObject } from 'openapi3-ts/oas31';
-import { S as StringOrBox, O as OpenapiSchemaConvertContext, L as LibSchemaObject, B as BoxFactory, m as mapOpenApiEndpoints, N as NameTransformOptions, a as OpenapiSchemaConvertArgs, b as Box, A as AnyBoxDef } from './types-DLE5RaXi.js';
-export { q as AnyBox, j as BoxArray, f as BoxDefinition, i as BoxIntersection, o as BoxKeyword, n as BoxLiteral, p as BoxObject, k as BoxOptional, g as BoxParams, l as BoxRef, h as BoxUnion, c as Endpoint, E as EndpointParameters, F as FactoryCreator, G as GenericFactory, M as Method, R as RefInfo, e as RefResolver, W as WithSchema, d as createRefResolver } from './types-DLE5RaXi.js';
+import { S as StringOrBox, O as OpenapiSchemaConvertContext, L as LibSchemaObject, B as BoxFactory, m as mapOpenApiEndpoints, N as NameTransformOptions, a as OpenapiSchemaConvertArgs, b as Box, A as AnyBoxDef } from './types-DsI2d-HE.js';
+export { q as AnyBox, j as BoxArray, f as BoxDefinition, i as BoxIntersection, o as BoxKeyword, n as BoxLiteral, p as BoxObject, k as BoxOptional, g as BoxParams, l as BoxRef, h as BoxUnion, c as Endpoint, E as EndpointParameters, F as FactoryCreator, G as GenericFactory, M as Method, R as RefInfo, e as RefResolver, W as WithSchema, d as createRefResolver } from './types-DsI2d-HE.js';
 import * as arktype_internal_methods_string_ts from 'arktype/internal/methods/string.ts';
 import * as Codegen from '@sinclair/typebox-codegen';
 import 'openapi3-ts/oas30';
@@ -16,6 +16,9 @@ type GeneratorOptions$1 = ReturnType<typeof mapOpenApiEndpoints> & {
     runtime?: "none" | keyof typeof runtimeValidationGenerator;
     schemasOnly?: boolean;
     nameTransform?: NameTransformOptions | undefined;
+    successStatusCodes?: readonly number[];
+    errorStatusCodes?: readonly number[];
+    includeClient?: boolean;
 };
 declare const allowedRuntimes: arktype_internal_methods_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
 type OutputRuntime = typeof allowedRuntimes.infer;
@@ -30,7 +33,9 @@ declare const runtimeValidationGenerator: {
 declare const generateFile: (options: GeneratorOptions$1) => string;
 
 type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints>;
-type GeneratorContext = Required<GeneratorOptions>;
+type GeneratorContext = Required<GeneratorOptions> & {
+    errorStatusCodes?: readonly number[];
+};
 declare const generateTanstackQueryFile: (ctx: GeneratorContext & {
     relativeApiClientPath: string;
 }) => Promise<string>;

package/dist/index.js

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