@sdk-it/typescript 0.37.1 → 0.39.0

package/dist/index.js

@@ -391,7 +391,7 @@ function toZod(schema, required) {
 }
 
 // packages/typescript/src/lib/client.ts
-var client_default = (spec, style) => {
+var client_default = (spec) => {
   const defaultHeaders = `{${spec.options.filter((value) => value.in === "header").map(
     (value) => `'${value.name}': options['${value["x-optionName"] ?? value.name}']`
   ).join(",\n")}}`;
@@ -429,9 +429,11 @@ var client_default = (spec, style) => {
     }
   };
   return `import z from 'zod';
+import { APIResponse } from '${spec.makeImport("./http/response")}';
 import type { HeadersInit, RequestConfig } from './http/${spec.makeImport("request")}';
 import { fetchType, parse } from './http/${spec.makeImport("dispatcher")}';
 import schemas from './api/${spec.makeImport("schemas")}';
+import type { InferData } from '${spec.makeImport("./api/endpoints")}';
 import {
   createBaseUrlInterceptor,
   createHeadersInterceptor,
@@ -454,56 +456,33 @@ export class ${spec.name} {
   async request<const E extends keyof typeof schemas>(
     endpoint: E,
     input: z.input<(typeof schemas)[E]['schema']>,
-    options?: { signal?: AbortSignal, headers?: HeadersInit },
-  ) ${style.errorAsValue ? `: Promise<Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>| [never, ParseError<(typeof schemas)[E]['schema']>]>` : `: Promise<Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>>`} {
-    const route = schemas[endpoint];
-    const withDefaultInputs = Object.assign({}, await this.#defaultInputs(), input);
-    const [parsedInput, parseError] = parseInput(route.schema, withDefaultInputs);
-    if (parseError) {
-      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
-    }
-    const clientOptions = await optionsSchema.parseAsync(this.options);
-    const result = await route.dispatch(parsedInput as never, {
-      fetch: clientOptions.fetch,
-      interceptors: [
-        createHeadersInterceptor(
-          await this.#defaultHeaders(),
-          options?.headers ?? {},
-        ),
-        createBaseUrlInterceptor(clientOptions.baseUrl),
-      ],
-      signal: options?.signal,
+    options?: { signal?: AbortSignal; headers?: HeadersInit },
+  ) {
+    return request(this, endpoint, input, options).then(function unwrap(it) {
+      if (it instanceof APIResponse) {
+        return it.data as InferData<E>;
+      }
+      return it as InferData<E>;
     });
-    return result as Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>;
   }
 
   async prepare<const E extends keyof typeof schemas>(
     endpoint: E,
     input: z.input<(typeof schemas)[E]['schema']>,
     options?: { headers?: HeadersInit },
-  ): ${style.errorAsValue ? `Promise<
-    readonly [
-      RequestConfig & {
-        parse: (response: Response) => ReturnType<typeof parse>;
-      },
-      ParseError<(typeof schemas)[E]['schema']> | null,
-    ]
-  >` : `Promise<RequestConfig & {
-        parse: (response: Response) => ReturnType<typeof parse>;
-      }>`} {
+  ): Promise<RequestConfig & {
+    parse: (response: Response) => ReturnType<typeof parse>;
+  }> {
     const clientOptions = await optionsSchema.parseAsync(this.options);
     const route = schemas[endpoint];
     const interceptors = [
       createHeadersInterceptor(
-        await this.#defaultHeaders(),
+        await this.defaultHeaders(),
         options?.headers ?? {},
       ),
       createBaseUrlInterceptor(clientOptions.baseUrl),
     ];
-    const [parsedInput, parseError] = parseInput(route.schema, input);
-    if (parseError) {
-      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
-    }
+    const parsedInput = parseInput(route.schema, input);
 
     let config = route.toRequest(parsedInput as never);
     for (const interceptor of interceptors) {
@@ -511,11 +490,11 @@ export class ${spec.name} {
         config = await interceptor.before(config);
       }
     }
-    const prepared = { ...config, parse: (response: Response) => parse(route.output, response) as never };
-    return ${style.errorAsValue ? "[prepared, null as never] as const;" : "prepared as any"}
+    const prepared = { ...config, parse: (response: Response) => parse(route.output, response, (d) => d) as never };
+    return prepared as any;
   }
 
-  async #defaultHeaders() {
+  async defaultHeaders() {
     const options = await optionsSchema.parseAsync(this.options);
     return {
       ...${defaultHeaders},
@@ -523,7 +502,7 @@ export class ${spec.name} {
     };
   }
 
-  async #defaultInputs() {
+  async defaultInputs() {
     const options = await optionsSchema.parseAsync(this.options);
     return ${defaultInputs}
   }
@@ -535,7 +514,38 @@ export class ${spec.name} {
     };
   }
 
-}`;
+}
+
+export async function request<const E extends keyof typeof schemas>(
+  client: ${spec.name},
+  endpoint: E,
+  input: z.input<(typeof schemas)[E]['schema']>,
+  options?: { signal?: AbortSignal; headers?: HeadersInit },
+): Promise<Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>> {
+  const route = schemas[endpoint];
+  const withDefaultInputs = Object.assign(
+    {},
+    await client.defaultInputs(),
+    input,
+  );
+  const parsedInput = parseInput(route.schema, withDefaultInputs);
+  const clientOptions = await optionsSchema.parseAsync(client.options);
+  const result = await route.dispatch(parsedInput as never, {
+    fetch: clientOptions.fetch,
+    interceptors: [
+      createHeadersInterceptor(
+        await client.defaultHeaders(),
+        options?.headers ?? {},
+      ),
+      createBaseUrlInterceptor(clientOptions.baseUrl),
+    ],
+    signal: options?.signal,
+  });
+  return result as Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>;
+}
+
+
+`;
 };
 
 // packages/typescript/src/lib/emitters/interface.ts
@@ -709,7 +719,7 @@ function appendOptional2(type, isRequired) {
 import { merge, template } from "lodash-es";
 import { join } from "node:path";
 import { camelcase as camelcase4, spinalcase as spinalcase2 } from "stringcase";
-import { followRef as followRef3, isEmpty as isEmpty2, isRef as isRef3, resolveRef } from "@sdk-it/core";
+import { followRef as followRef3, isEmpty as isEmpty2, isRef as isRef3, resolveRef, sortArray } from "@sdk-it/core";
 import {
   forEachOperation as forEachOperation3
 } from "@sdk-it/spec";
@@ -754,7 +764,7 @@ var status_map_default = {
 };
 
 // packages/typescript/src/lib/sdk.ts
-function toEndpoint(groupName, spec, specOperation, operation, utils) {
+function toEndpoint(groupName, spec, specOperation, operation) {
   const schemaName = camelcase3(`${specOperation.operationId} schema`);
   const schemaRef = `${camelcase3(groupName)}.${schemaName}`;
   const schemas = [];
@@ -790,23 +800,22 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
             signal?: AbortSignal;
             interceptors: Interceptor[];
             fetch: z.infer<typeof fetchType>;
-          })${specOperation["x-pagination"] ? paginationOperation(specOperation, utils.style) : normalOperation(utils.style)}`
+          })${specOperation["x-pagination"] ? paginationOperation(specOperation) : normalOperation()}`
     );
   }
   return { schemas };
 }
-function normalOperation(style) {
+function normalOperation() {
   return `{
             const dispatcher = new Dispatcher(options.interceptors, options.fetch);
-            const result = await dispatcher.send(this.toRequest(input), this.output);
-            return ${style?.outputType === "status" ? "result" : style?.errorAsValue ? `result` : "result.data;"}
+            return dispatcher.send(this.toRequest(input), this.output, options?.signal);
             },
           }`;
 }
-function paginationOperation(operation, style) {
+function paginationOperation(operation) {
   const pagination = operation["x-pagination"];
-  const data = `${style?.errorAsValue ? `result[0]${style.outputType === "status" ? "" : ""}` : `${style?.outputType === "default" ? "result.data" : "result.data"}`}`;
-  const returnValue = `${style?.errorAsValue ? `[${style?.outputType === "status" ? "new http.Ok(pagination)" : "pagination"}, null]` : `${style?.outputType === "status" ? "new http.Ok(pagination);" : "pagination"}`}`;
+  const data = `result.data`;
+  const returnValue = `pagination`;
   if (pagination.type === "offset") {
     const sameInputNames = pagination.limitParamName === "limit" && pagination.offsetParamName === "offset";
     const initialParams = sameInputNames ? "input" : `{...input, limit: input.${pagination.limitParamName}, offset: input.${pagination.offsetParamName}}`;
@@ -816,6 +825,7 @@ function paginationOperation(operation, style) {
         const result = await dispatcher.send(
           this.toRequest({...input, ${nextPageParams}}),
           this.output,
+          options.signal,
         );
         return {
           data: ${data}.${pagination.items},
@@ -827,7 +837,7 @@ function paginationOperation(operation, style) {
       await pagination.getNextPage();
       return ${returnValue}
       `;
-    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+    return `{${logic}}}`;
   }
   if (pagination.type === "cursor") {
     const sameInputNames = pagination.cursorParamName === "cursor";
@@ -839,8 +849,8 @@ function paginationOperation(operation, style) {
         const result = await dispatcher.send(
           this.toRequest({...input, ${nextPageParams}}),
           this.output,
+          options.signal,
         );
-        ${style?.errorAsValue ? `if (result[1]) {throw result[1];}` : ""}
         return {
           data: ${data}.${pagination.items},
           meta: {
@@ -851,7 +861,7 @@ function paginationOperation(operation, style) {
       await pagination.getNextPage();
       return ${returnValue}
       `;
-    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+    return `{${logic}}}`;
   }
   if (pagination.type === "page") {
     const sameInputNames = pagination.pageNumberParamName === "page" && pagination.pageSizeParamName === "pageSize";
@@ -863,8 +873,8 @@ function paginationOperation(operation, style) {
         const result = await dispatcher.send(
           this.toRequest({...input, ${nextPageParams}}),
           this.output,
+          options.signal,
         );
-        ${style?.errorAsValue ? `if (result[1]) {throw result[1];}` : ""}
         return {
           data: ${data}.${pagination.items},
           meta: {
@@ -872,12 +882,11 @@ function paginationOperation(operation, style) {
           },
         };
       });
-      await pagination.getNextPage();
       return ${returnValue}
       `;
-    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+    return `{${logic}}}`;
   }
-  return normalOperation(style);
+  return normalOperation();
 }
 function toHttpOutput(spec, operationName, status, response, withGenerics = true) {
   const typeScriptDeserialzer = new TypeScriptEmitter(spec);
@@ -975,7 +984,7 @@ function inputToPath(operation, inputs) {
 }
 
 // packages/typescript/src/lib/styles/github/endpoints.txt
-var endpoints_default = "type EndpointOutput<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  SuccessfulResponse\n>;\n\ntype EndpointError<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  ProblematicResponse\n>;\n\nexport type Endpoints = {\n  [K in keyof typeof schemas]: {\n    input: z.input<(typeof schemas)[K]['schema']>;\n    output: <% if (outputType === 'default') { %>EndpointOutput<K>['data']<% } else { %>EndpointOutput<K><% } %>;\n    error: EndpointError<K> | ParseError<(typeof schemas)[K]['schema']>;\n  };\n};";
+var endpoints_default = "type DispatchReturn<E extends keyof typeof schemas> = Awaited<\n  ReturnType<(typeof schemas)[E]['dispatch']>\n>;\n\nexport type InferData<E extends keyof typeof schemas> =\n  DispatchReturn<E> extends APIResponse<infer D> ? D : DispatchReturn<E>;\n\ntype EndpointOutput<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  SuccessfulResponse\n>;\n\ntype EndpointError<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  ProblematicResponse\n>;\n\nexport type Endpoints = {\n  [E in keyof typeof schemas]: {\n    input: z.input<(typeof schemas)[E]['schema']>;\n    output: InferData<E>;\n    error: EndpointError<E> | ParseError<(typeof schemas)[E]['schema']>;\n  };\n};\n";
 
 // packages/typescript/src/lib/generator.ts
 function coearceRequestInput(spec, operation, type) {
@@ -1045,20 +1054,14 @@ function generateCode(config) {
       );
     }
     const details = buildInput(config.spec, operation);
-    const endpoint = toEndpoint(
-      entry.tag,
-      config.spec,
-      operation,
-      {
-        method: entry.method,
-        path: entry.path,
-        operationId: operation.operationId,
-        schemas,
-        outgoingContentType: details.outgoingContentType,
-        inputs: details.inputs
-      },
-      config
-    );
+    const endpoint = toEndpoint(entry.tag, config.spec, operation, {
+      method: entry.method,
+      path: entry.path,
+      operationId: operation.operationId,
+      schemas,
+      outgoingContentType: details.outgoingContentType,
+      inputs: details.inputs
+    });
     endpoints[entry.tag].push(endpoint);
     groups[entry.tag].push({
       method: entry.method,
@@ -1078,19 +1081,17 @@ function generateCode(config) {
     commonZod,
     endpoints: {
       [join("api", "endpoints.ts")]: `
-
-
 import type z from 'zod';
 import type { ParseError } from '${config.makeImport("../http/parser")}';
-import type { ProblematicResponse, SuccessfulResponse } from '${config.makeImport(
+import type { ProblematicResponse, SuccessfulResponse, APIResponse } from '${config.makeImport(
         "../http/response"
       )}';
 
 import schemas from '${config.makeImport("./schemas")}';
 import type { Unionize } from '${config.makeImport("../http/dispatcher")}';
-      ${template(endpoints_default)({ outputType: config.style?.outputType })}`,
+      ${template(endpoints_default)({})}`,
       [`${join("api", "schemas.ts")}`]: `${allSchemas.map((it) => it.import).join("\n")}
-import { KIND } from "${config.makeImport("../http/index")}";
+
 export default {
 ${allSchemas.map((it) => it.use).join(",\n")}
 };
@@ -1158,15 +1159,18 @@ function toProps(spec, schemaOrRef, aggregator = []) {
 function bodyInputs(spec, ctSchema) {
   const props = [];
   toProps(spec, ctSchema, props);
-  return props.reduce(
-    (acc, prop) => ({
-      ...acc,
-      [prop]: {
-        in: "body",
-        schema: ""
-      }
-    }),
-    {}
+  return (
+    // TODO: should we preproccess the sort at spec level instead of generator's?
+    sortArray(props).reduce(
+      (acc, prop) => ({
+        ...acc,
+        [prop]: {
+          in: "body",
+          schema: ""
+        }
+      }),
+      {}
+    )
   );
 }
 var contentTypeSerializerMap = {
@@ -1232,7 +1236,7 @@ function operationSchema(ir, operation, type) {
 }
 
 // packages/typescript/src/lib/http/dispatcher.txt
-var dispatcher_default = "export type Unionize<T> = T extends [infer Single extends OutputType]\n  ? InstanceType<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: InstanceType<Tuple[I]> }[number]\n    : never;\n\nexport type InstanceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends { type: Type<infer U> }\n      ? U\n      : T extends Array<unknown>\n        ? Unionize<T>\n        : never;\n\nexport interface Type<T> {\n  new (...args: any[]): T;\n}\nexport type Parser = (\n  response: Response,\n) => Promise<unknown> | ReadableStream<any>;\nexport type OutputType =\n  | Type<APIResponse>\n  | { parser: Parser; type: Type<APIResponse> };\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function parse<T extends OutputType[]>(\n  outputs: T,\n  response: Response,\n) <% if(!throwError) { %>\n: Promise<\n  [\n    Extract<InstanceType<T>, SuccessfulResponse>['data'],\n    Extract<InstanceType<T>, ProblematicResponse>['data'],\n  ]\n>\n  <% } %>\n\n\n\n {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of outputs) {\n    if ('parser' in outputType) {\n      parser = outputType.parser;\n      if (isTypeOf(outputType.type, APIResponse)) {\n        if (response.status === outputType.type.status) {\n          output = outputType.type;\n          break;\n        }\n      }\n    } else if (isTypeOf(outputType, APIResponse)) {\n      if (response.status === outputType.status) {\n        output = outputType;\n        break;\n      }\n    }\n  }\n\n\n  if (response.ok) {\n    const apiresponse = (output || APIResponse).create(\n      response.status,\n      await parser(response),\n    );\n    <% if(throwError) { %>\n      return <% if (outputType === 'default') { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse><% } else { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse>;<% } %>;\n    <% } else { %>\n      return [<% if (outputType === 'default') { %>apiresponse.data as Extract<InstanceType<T>, SuccessfulResponse>['data']<% } else { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse><% } %>, null] as const;\n    <% } %>\n  }\n<% if(throwError) { %>\n  throw (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n<% } else { %>\n  const data = (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n  return [null, data] as const;\n<% } %>\n}\n\nexport function isTypeOf<T extends Type<APIResponse>>(\n  instance: any,\n  baseType: T,\n): instance is T {\n  if (instance === baseType) {\n    return true;\n  }\n  const prototype = Object.getPrototypeOf(instance);\n  if (prototype === null) {\n    return false;\n  }\n  return isTypeOf(prototype, baseType);\n}\n\nexport class Dispatcher {\n  #interceptors: Interceptor[] = [];\n  #fetch: z.infer<typeof fetchType>;\n  constructor(interceptors: Interceptor[], fetch?: z.infer<typeof fetchType>) {\n    this.#interceptors = interceptors;\n    this.#fetch = fetch;\n  }\n\n  async send<T extends OutputType[]>(\n    config: RequestConfig,\n    outputs: T,\n    signal?: AbortSignal,\n  ) {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor.before) {\n        config = await interceptor.before(config);\n      }\n    }\n\n    let response = await (this.#fetch ?? fetch)(\n      new Request(config.url, config.init),\n      {\n        ...config.init,\n        signal: signal,\n      },\n    );\n\n    for (let i = this.#interceptors.length - 1; i >= 0; i--) {\n      const interceptor = this.#interceptors[i];\n      if (interceptor.after) {\n        response = await interceptor.after(response.clone());\n      }\n    }\n\n    return await parse(outputs, response);\n  }\n}\n";
+var dispatcher_default = "export type Unionize<T> = T extends [infer Single extends OutputType]\n  ? InstanceType<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: InstanceType<Tuple[I]> }[number]\n    : never;\n\nexport type InstanceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends { type: Type<infer U> }\n      ? U\n      : T extends Array<unknown>\n        ? Unionize<T>\n        : never;\n\ntype ResponseData<T extends OutputType[]> =\n  Extract<InstanceType<T>, SuccessfulResponse> extends SuccessfulResponse<\n    infer P\n  >\n    ? P\n    : unknown;\n\ntype ResponseMapper<T extends OutputType[], R> = (data: ResponseData<T>) => R;\n\nexport interface Type<T> {\n  new (...args: any[]): T;\n}\nexport type Parser = (\n  response: Response,\n) => Promise<unknown> | ReadableStream<any>;\nexport type OutputType =\n  | Type<APIResponse>\n  | { parser: Parser; type: Type<APIResponse> };\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function parse<T extends OutputType[], R = ResponseData<T>>(\n  outputs: T,\n  response: Response,\n  mapper: ResponseMapper<T, R>,\n) {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of outputs) {\n    if ('parser' in outputType) {\n      parser = outputType.parser;\n      if (isTypeOf(outputType.type, APIResponse)) {\n        if (response.status === outputType.type.status) {\n          output = outputType.type;\n          break;\n        }\n      }\n    } else if (isTypeOf(outputType, APIResponse)) {\n      if (response.status === outputType.status) {\n        output = outputType;\n        break;\n      }\n    }\n  }\n\n  if (response.ok) {\n    const apiresponse = (output || APIResponse).create(\n      response.status,\n      response.headers,\n      mapper((await parser(response)) as ResponseData<T>),\n    );\n\n    return apiresponse as RebindSuccessPayload<Extract<InstanceType<T>, SuccessfulResponse<unknown>>, R>;\n  }\n\n  throw (output || APIError).create(\n    response.status,\n    response.headers,\n    await parser(response),\n  );\n}\n\nexport function isTypeOf<T extends Type<APIResponse>>(\n  instance: any,\n  baseType: T,\n): instance is T {\n  if (instance === baseType) {\n    return true;\n  }\n  const prototype = Object.getPrototypeOf(instance);\n  if (prototype === null) {\n    return false;\n  }\n  return isTypeOf(prototype, baseType);\n}\n\nexport class Dispatcher {\n  #interceptors: Interceptor[] = [];\n  #fetch: z.infer<typeof fetchType>;\n  constructor(interceptors: Interceptor[], fetch?: z.infer<typeof fetchType>) {\n    this.#interceptors = interceptors;\n    this.#fetch = fetch;\n  }\n\n  async send<T extends OutputType[], R = ResponseData<T>>(\n    config: RequestConfig,\n    outputs: T,\n    signal?: AbortSignal,\n    mapper?: ResponseMapper<T, R>,\n  ) {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor.before) {\n        config = await interceptor.before(config);\n      }\n    }\n\n    let response = await (this.#fetch ?? fetch)(\n      new Request(config.url, config.init),\n      {\n        ...config.init,\n        signal: signal,\n      },\n    );\n\n    for (let i = this.#interceptors.length - 1; i >= 0; i--) {\n      const interceptor = this.#interceptors[i];\n      if (interceptor.after) {\n        response = await interceptor.after(response.clone());\n      }\n    }\n\n    return await parse(\n      outputs,\n      response,\n      mapper ?? ((data: ResponseData<T>) => data as unknown as R),\n    );\n  }\n}\n";
 
 // packages/typescript/src/lib/http/interceptors.txt
 var interceptors_default = "export interface Interceptor {\n  before?: (config: RequestConfig) => Promise<RequestConfig> | RequestConfig;\n  after?: (response: Response) => Promise<Response> | Response;\n}\n\nexport const createHeadersInterceptor = (\n  headers: Record<string, string | undefined>,\n  requestHeaders: HeadersInit,\n):Interceptor => {\n  return {\n    before({init, url}) {\n      // Priority Levels\n      // 1. Headers Input\n      // 2. Request Headers\n      // 3. Default Headers\n\n      for (const [key, value] of new Headers(requestHeaders)) {\n        // Only set the header if it doesn't already exist and has a value\n        // even though these headers are passed at operation level\n        // still they are lower priority compared to the headers input\n        if (value !== undefined && !init.headers.has(key)) {\n          init.headers.set(key, value);\n        }\n      }\n\n      for (const [key, value] of Object.entries(headers)) {\n        // Only set the header if it doesn't already exist and has a value\n        if (value !== undefined && !init.headers.has(key)) {\n          init.headers.set(key, value);\n        }\n      }\n\n      return {init, url};\n    },\n  };\n};\n\nexport const createBaseUrlInterceptor = (baseUrl: string): Interceptor => {\n  return {\n    before({ init, url }) {\n      if (url.protocol === 'local:') {\n        return {\n          init,\n          url: new URL(url.href.replace('local://', baseUrl))\n        };\n      }\n      return { init, url };\n    },\n  };\n};\n\nexport const logInterceptor: Interceptor = {\n  before({ url, init }) {\n    console.log('Request:', { url, init });\n    return { url, init };\n  },\n  after(response) {\n    console.log('Response:', response);\n    return response;\n  },\n};\n\n/**\n * Creates an interceptor that logs detailed information about requests and responses.\n * @param options Configuration options for the logger\n * @returns An interceptor object with before and after handlers\n */\nexport const createDetailedLogInterceptor = (options?: {\n  logLevel?: 'debug' | 'info' | 'warn' | 'error';\n  includeRequestBody?: boolean;\n  includeResponseBody?: boolean;\n}) => {\n  const logLevel = options?.logLevel || 'info';\n  const includeRequestBody = options?.includeRequestBody || false;\n  const includeResponseBody = options?.includeResponseBody || false;\n\n  return {\n    async before(request: Request) {\n      const logData = {\n        url: request.url,\n        method: request.method,\n        contentType: request.headers.get('Content-Type'),\n        headers: Object.fromEntries([...request.headers.entries()]),\n      };\n\n      console[logLevel]('\u{1F680} Outgoing Request:', logData);\n\n      if (includeRequestBody) {\n        try {\n          // Clone the request to avoid consuming the body stream\n          const clonedRequest = request.clone();\n          if (clonedRequest.headers.get('Content-Type')?.includes('application/json')) {\n            const body = await clonedRequest.json().catch(() => null);\n            console[logLevel]('Request Body:', body);\n          } else {\n            const body = await clonedRequest.text().catch(() => null);\n            console[logLevel]('Request Body:', body);\n          }\n        } catch (error) {\n          console.error('Could not log request body:', error);\n        }\n      }\n\n      return request;\n    },\n\n    async after(response: Response) {\n      const logData = {\n        status: response.status,\n        statusText: response.statusText,\n        url: response.url,\n        headers: Object.fromEntries([...response.headers.entries()]),\n      };\n\n      console[logLevel]('\u{1F4E5} Incoming Response:', logData);\n\n      if (includeResponseBody && response.body) {\n        try {\n          // Clone the response to avoid consuming the body stream\n          const clonedResponse = response.clone();\n          if (clonedResponse.headers.get('Content-Type')?.includes('application/json')) {\n            const body = await clonedResponse.json().catch(() => null);\n            console[logLevel]('Response Body:', body);\n          } else {\n            const body = await clonedResponse.text().catch(() => null);\n            if (body) {\n              console[logLevel]('Response Body:', body.substring(0, 500) + (body.length > 500 ? '...' : ''));\n            } else {\n              console[logLevel]('No response body');\n            }\n          }\n        } catch (error) {\n          console.error('Could not log response body:', error);\n        }\n      }\n\n      return response;\n    },\n  };\n};\n";
@@ -1241,445 +1245,13 @@ var interceptors_default = "export interface Interceptor {\n  before?: (config:
 var parse_response_default = 'import { parse } from "fast-content-type-parse";\n\nasync function handleChunkedResponse(response: Response, contentType: string) {\n	const { type } = parse(contentType);\n\n	switch (type) {\n		case "application/json": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return JSON.parse(buffer);\n		}\n		case "text/html":\n		case "text/plain": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return buffer;\n		}\n		default:\n			return response.body;\n	}\n}\n\nexport function chunked(response: Response) {\n	return response.body!;\n}\n\nexport async function buffered(response: Response) {\n	const contentType = response.headers.get("Content-Type");\n	if (!contentType) {\n		throw new Error("Content-Type header is missing");\n	}\n\n	if (response.status === 204) {\n		return null;\n	}\n\n	const { type } = parse(contentType);\n	switch (type) {\n		case "application/json":\n			return response.json();\n		case "text/plain":\n			return response.text();\n		case "text/html":\n			return response.text();\n		case "text/xml":\n		case "application/xml":\n			return response.text();\n		case "application/x-www-form-urlencoded": {\n			const text = await response.text();\n			return Object.fromEntries(new URLSearchParams(text));\n		}\n		case "multipart/form-data":\n			return response.formData();\n		default:\n			throw new Error(`Unsupported content type: ${contentType}`);\n	}\n}\n';
 
 // packages/typescript/src/lib/http/parser.txt
-var parser_default = "import { z } from 'zod';\n\nexport class ParseError<T extends z.ZodType<any, any, any>> {\n  public data: z.typeToFlattenedError<T, z.ZodIssue>;\n  constructor(data: z.typeToFlattenedError<T, z.ZodIssue>) {\n    this.data = data;\n  }\n}\n\nexport function parseInput<T extends z.ZodType<any, any, any>>(\n  schema: T,\n  input: unknown,\n) {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const error = result.error.flatten((issue) => issue);\n    return [null, new ParseError(error)];\n  }\n  return [result.data as z.infer<T>, null];\n}\n";
+var parser_default = "import { z } from 'zod';\n\nexport class ParseError<T extends z.ZodType<any, any, any>> extends Error {\n  public data: z.typeToFlattenedError<T, z.ZodIssue>;\n  constructor(data: z.typeToFlattenedError<T, z.ZodIssue>) {\n    super('Validation failed');\n    this.name = 'ParseError';\n    this.data = data;\n  }\n}\n\nexport function parseInput<T extends z.ZodType<any, any, any>>(\n  schema: T,\n  input: unknown,\n): z.infer<T> {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const error = result.error.flatten((issue) => issue);\n    throw new ParseError(error);\n  }\n  return result.data as z.infer<T>;\n}\n";
 
 // packages/typescript/src/lib/http/request.txt
 var request_default = "type Init = Omit<RequestInit, 'headers'> & { headers: Headers };\nexport type RequestConfig = { init: Init; url: URL };\nexport type Method =\n  | 'GET'\n  | 'POST'\n  | 'PUT'\n  | 'PATCH'\n  | 'DELETE'\n  | 'HEAD'\n  | 'OPTIONS';\nexport type ContentType =\n  | 'xml'\n  | 'json'\n  | 'urlencoded'\n  | 'multipart'\n  | 'formdata';\nexport type HeadersInit = [string, string][] | Record<string, string>;\nexport type Endpoint =\n  | `${ContentType} ${Method} ${string}`\n  | `${Method} ${string}`;\n\nexport type BodyInit =\n  | ArrayBuffer\n  | Blob\n  | FormData\n  | URLSearchParams\n  | null\n  | string;\n\nfunction template(\n  templateString: string,\n  templateVariables: Record<string, any>,\n): string {\n  const nargs = /{([0-9a-zA-Z_]+)}/g;\n  return templateString.replace(nargs, (match, key: string, index: number) => {\n    // Handle escaped double braces\n    if (\n      templateString[index - 1] === '{' &&\n      templateString[index + match.length] === '}'\n    ) {\n      return key;\n    }\n\n    const result = key in templateVariables ? templateVariables[key] : null;\n    return result === null || result === undefined ? '' : String(result);\n  });\n}\n\ntype Input = Record<string, any>;\ntype Props = {\n  inputHeaders: string[];\n  inputQuery: string[];\n  inputBody: string[];\n  inputParams: string[];\n};\n\nabstract class Serializer {\n  protected input: Input;\n  protected props: Props;\n\n  constructor(input: Input, props: Props) {\n    this.input = input;\n    this.props = props;\n  }\n\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Record<string, string>;\n  serialize(path: string): Serialized {\n    const params = this.props.inputParams.reduce<Record<string, any>>(\n      (acc, key) => {\n        acc[key] = this.input[key];\n        return acc;\n      },\n      {},\n    );\n    const url = new URL(template(path, params), `local://`);\n\n    const headers = new Headers({});\n    for (const header of this.props.inputHeaders) {\n      headers.set(header, this.input[header]);\n    }\n\n    for (const key of this.props.inputQuery) {\n      const value = this.input[key];\n      if (value !== undefined) {\n        if (Array.isArray(value)) {\n          for (const item of value) {\n            url.searchParams.append(key, String(item));\n          }\n        } else {\n          url.searchParams.set(key, String(value));\n        }\n      }\n    }\n\n    return {\n      body: this.getBody(),\n      url,\n      headers: this.getHeaders(),\n    };\n  }\n}\n\ninterface Serialized {\n  body: BodyInit | null;\n  headers: Record<string, string>;\n  url: URL;\n}\n\nclass JsonSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body: Record<string, any> = {};\n    if (\n      this.props.inputBody.length === 1 &&\n      this.props.inputBody[0] === '$body'\n    ) {\n      return JSON.stringify(this.input.$body);\n    }\n\n    for (const prop of this.props.inputBody) {\n      body[prop] = this.input[prop];\n    }\n    return JSON.stringify(body);\n  }\n  getHeaders(): Record<string, string> {\n    return {\n      'Content-Type': 'application/json',\n      Accept: 'application/json',\n    };\n  }\n}\n\nclass UrlencodedSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new URLSearchParams();\n    for (const prop of this.props.inputBody) {\n      body.set(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {\n      'Content-Type': 'application/x-www-form-urlencoded',\n      Accept: 'application/json',\n    };\n  }\n}\n\nclass EmptySerializer extends Serializer {\n  getBody(): BodyInit | null {\n    return null;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass FormDataSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new FormData();\n    for (const prop of this.props.inputBody) {\n      body.append(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {\n      Accept: 'application/json',\n    };\n  }\n}\n\nexport function json(input: Input, props: Props) {\n  return new JsonSerializer(input, props);\n}\nexport function urlencoded(input: Input, props: Props) {\n  return new UrlencodedSerializer(input, props);\n}\nexport function empty(input: Input, props: Props) {\n  return new EmptySerializer(input, props);\n}\nexport function formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props);\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  serializer: Serializer,\n): RequestConfig {\n  const [method, path] = endpoint.split(' ');\n  const input = serializer.serialize(path);\n  return {\n    url: input.url,\n    init: {\n      method: method,\n      headers: new Headers(input.headers),\n      body: method === 'GET' ? undefined : input.body,\n    },\n  };\n}\n";
 
 // packages/typescript/src/lib/http/response.txt
-var response_default = `export const KIND = Symbol('APIDATA');
-
-export class APIResponse<Body = unknown, Status extends number = number> {
-  static readonly status: number;
-  static readonly kind: symbol = Symbol.for("APIResponse");
-  status: Status;
-  data: Body;
-
-  constructor(status: Status, data: Body) {
-    this.status = status;
-    this.data = data;
-  }
-
-  static create<Body = unknown>(status: number, data: Body) {
-    return new this(status, data);
-  }
-
-}
-
-export class APIError<Body, Status extends number = number> extends APIResponse<
-  Body,
-  Status
-> {
-  static override create<T>(status: number, data: T) {
-    return new this(status, data);
-  }
-}
-
-
-// 2xx Success
-export class Ok<T> extends APIResponse<T, 200> {
-  static override readonly kind =  Symbol.for("Ok");
-  static override readonly status = 200 as const;
-  constructor(data: T) {
-    super(Ok.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]:typeof Ok['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-
-
-export class Created<T> extends APIResponse<T, 201> {
-  static override readonly kind = Symbol.for("Created");
-  static override status = 201 as const;
-  constructor(data: T) {
-    super(Created.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof Created['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class Accepted<T> extends APIResponse<T, 202> {
-  static override readonly kind = Symbol.for("Accepted");
-  static override status = 202 as const;
-  constructor(data: T) {
-    super(Accepted.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof Accepted['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class NoContent extends APIResponse<never, 204> {
-  static override readonly kind = Symbol.for("NoContent");
-  static override status = 204 as const;
-  constructor() {
-    super(NoContent.status, null as never);
-  }
-  static override create(status: number, data: never): NoContent {
-    return new this();
-  }
-
-  static is<T extends {[KIND]: typeof NoContent['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-
-// 4xx Client Errors
-export class BadRequest<T> extends APIError<T, 400> {
-  static override readonly kind = Symbol.for("BadRequest");
-  static override status = 400 as const;
-  constructor(data: T) {
-    super(BadRequest.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof BadRequest['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class Unauthorized<T = { message: string }> extends APIError<T, 401> {
-  static override readonly kind = Symbol.for("Unauthorized");
-  static override status = 401 as const;
-  constructor(data: T) {
-    super(Unauthorized.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof Unauthorized['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class PaymentRequired<T = { message: string }> extends APIError<T, 402> {
-  static override readonly kind = Symbol.for("PaymentRequired");
-  static override status = 402 as const;
-  constructor(data: T) {
-    super(PaymentRequired.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof PaymentRequired['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class Forbidden<T = { message: string }> extends APIError<T, 403> {
-  static override readonly kind = Symbol.for("Forbidden");
-  static override status = 403 as const;
-  constructor(data: T) {
-    super(Forbidden.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof Forbidden['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class NotFound<T = { message: string }> extends APIError<T, 404> {
-  static override readonly kind = Symbol.for("NotFound");
-  static override status = 404 as const;
-  constructor(data: T) {
-    super(NotFound.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof NotFound['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class MethodNotAllowed<T = { message: string }> extends APIError<
-  T,
-  405
-> {
-  static override readonly kind = Symbol.for("MethodNotAllowed");
-  static override status = 405 as const;
-  constructor(data: T) {
-    super(MethodNotAllowed.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof MethodNotAllowed['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class NotAcceptable<T = { message: string }> extends APIError<T, 406> {
-  static override readonly kind = Symbol.for("NotAcceptable");
-  static override status = 406 as const;
-  constructor(data: T) {
-    super(NotAcceptable.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof NotAcceptable['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class Conflict<T = { message: string }> extends APIError<T, 409> {
-  static override readonly kind = Symbol.for("Conflict");
-  static override status = 409 as const;
-  constructor(data: T) {
-    super(Conflict.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof Conflict['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class Gone<T = { message: string }> extends APIError<T, 410> {
-  static override readonly kind = Symbol.for("Gone");
-  static override status = 410 as const;
-  constructor(data: T) {
-    super(Gone.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof Gone['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class PreconditionFailed<T = { message: string }> extends APIError<T, 412> {
-  static override readonly kind = Symbol.for('PreconditionFailed');
-  static override status = 412 as const;
-  constructor(data: T) {
-    super(PreconditionFailed.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends { [KIND]: (typeof PreconditionFailed)['kind'] }>(
-    value: unknown,
-  ): value is T {
-    return (
-      typeof value === 'object' &&
-      value !== null &&
-      KIND in value &&
-      value[KIND] === this.kind
-    );
-  }
-}
-export class UnprocessableEntity<
-  T = { message: string; errors?: Record<string, string[]> },
-> extends APIError<T, 422> {
-  static override readonly kind = Symbol.for("UnprocessableEntity");
-  static override status = 422 as const;
-  constructor(data: T) {
-    super(UnprocessableEntity.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof UnprocessableEntity['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class TooManyRequests<
-  T = { message: string; retryAfter?: string },
-> extends APIError<T, 429> {
-  static override readonly kind = Symbol.for("TooManyRequests");
-  static override status = 429 as const;
-  constructor(data: T) {
-    super(TooManyRequests.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof TooManyRequests['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class PayloadTooLarge<T = { message: string }> extends APIError<T, 413> {
-  static override readonly kind = Symbol.for("PayloadTooLarge");
-  static override status = 413 as const;
-  constructor(data: T) {
-    super(PayloadTooLarge.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof PayloadTooLarge['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class UnsupportedMediaType<T = { message: string }> extends APIError<
-  T,
-  415
-> {
-  static override readonly kind = Symbol.for("UnsupportedMediaType");
-  static override status = 415 as const;
-  constructor(data: T) {
-    super(UnsupportedMediaType.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof UnsupportedMediaType['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-
-// 5xx Server Errors
-export class InternalServerError<T = { message: string }> extends APIError<
-  T,
-  500
-> {
-  static override readonly kind = Symbol.for("InternalServerError");
-  static override status = 500 as const;
-  constructor(data: T) {
-    super(InternalServerError.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof InternalServerError['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class NotImplemented<T = { message: string }> extends APIError<T, 501> {
-  static override readonly kind = Symbol.for("NotImplemented");
-  static override status = 501 as const;
-  constructor(data: T) {
-    super(NotImplemented.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof NotImplemented['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class BadGateway<T = { message: string }> extends APIError<T, 502> {
-  static override readonly kind = Symbol.for("BadGateway");
-  static override status = 502 as const;
-  constructor(data: T) {
-    super(BadGateway.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof BadGateway['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class ServiceUnavailable<
-  T = { message: string; retryAfter?: string },
-> extends APIError<T, 503> {
-  static override readonly kind = Symbol.for("ServiceUnavailable");
-  static override status = 503 as const;
-  constructor(data: T) {
-    super(ServiceUnavailable.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof ServiceUnavailable['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-export class GatewayTimeout<T = { message: string }> extends APIError<T, 504> {
-  static override readonly kind = Symbol.for("GatewayTimeout");
-  static override status = 504 as const;
-  constructor(data: T) {
-    super(GatewayTimeout.status, data);
-  }
-  static override create<T>(status: number, data: T) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-
-  static is<T extends {[KIND]: typeof GatewayTimeout['kind']}>(value: unknown): value is T {
-    return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
-  }
-}
-
-export type ClientError =
-  | BadRequest<unknown>
-  | Unauthorized<unknown>
-  | PaymentRequired<unknown>
-  | Forbidden<unknown>
-  | NotFound<unknown>
-  | MethodNotAllowed<unknown>
-  | NotAcceptable<unknown>
-  | Conflict<unknown>
-  | Gone<unknown>
-  | PreconditionFailed<unknown>
-  | PayloadTooLarge<unknown>
-  | UnsupportedMediaType<unknown>
-  | UnprocessableEntity<unknown>
-  | TooManyRequests<unknown>;
-
-export type ServerError =
-  | InternalServerError<unknown>
-  | NotImplemented<unknown>
-  | BadGateway<unknown>
-  | ServiceUnavailable<unknown>
-  | GatewayTimeout<unknown>;
-
-export type ProblematicResponse = ClientError | ServerError;
-
-export type SuccessfulResponse =
-  | Ok<unknown>
-  | Created<unknown>
-  | Accepted<unknown>
-  | NoContent;`;
+var response_default = "export class APIResponse<Body = unknown, Status extends number = number> {\n  static readonly status: number;\n  readonly status: Status;\n  data: Body;\n  readonly headers: Headers;\n\n  constructor(status: Status, headers: Headers, data: Body) {\n    this.status = status;\n    this.headers = headers;\n    this.data = data;\n  }\n\n  static create<Body = unknown>(status: number, headers: Headers, data: Body) {\n    return new this(status, headers, data);\n  }\n}\n\nexport class APIError<Body, Status extends number = number> extends APIResponse<\n  Body,\n  Status\n> {\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(status, headers, data);\n  }\n}\n\n// 2xx Success\nexport class Ok<T> extends APIResponse<T, 200> {\n  static override readonly status = 200 as const;\n  constructor(headers: Headers, data: T) {\n    super(Ok.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\n\nexport class Created<T> extends APIResponse<T, 201> {\n  static override status = 201 as const;\n  constructor(headers: Headers, data: T) {\n    super(Created.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Accepted<T> extends APIResponse<T, 202> {\n  static override status = 202 as const;\n  constructor(headers: Headers, data: T) {\n    super(Accepted.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NoContent extends APIResponse<never, 204> {\n  static override status = 204 as const;\n  constructor(headers: Headers) {\n    super(NoContent.status, headers, null as never);\n  }\n  static override create(status: number, headers: Headers): NoContent {\n    return new this(headers);\n  }\n}\n\n// 4xx Client Errors\nexport class BadRequest<T> extends APIError<T, 400> {\n  static override status = 400 as const;\n  constructor(headers: Headers, data: T) {\n    super(BadRequest.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Unauthorized<T = { message: string }> extends APIError<T, 401> {\n  static override status = 401 as const;\n  constructor(headers: Headers, data: T) {\n    super(Unauthorized.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class PaymentRequired<T = { message: string }> extends APIError<T, 402> {\n  static override status = 402 as const;\n  constructor(headers: Headers, data: T) {\n    super(PaymentRequired.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Forbidden<T = { message: string }> extends APIError<T, 403> {\n  static override status = 403 as const;\n  constructor(headers: Headers, data: T) {\n    super(Forbidden.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NotFound<T = { message: string }> extends APIError<T, 404> {\n  static override status = 404 as const;\n  constructor(headers: Headers, data: T) {\n    super(NotFound.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class MethodNotAllowed<T = { message: string }> extends APIError<\n  T,\n  405\n> {\n  static override status = 405 as const;\n  constructor(headers: Headers, data: T) {\n    super(MethodNotAllowed.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NotAcceptable<T = { message: string }> extends APIError<T, 406> {\n  static override status = 406 as const;\n  constructor(headers: Headers, data: T) {\n    super(NotAcceptable.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Conflict<T = { message: string }> extends APIError<T, 409> {\n  static override status = 409 as const;\n  constructor(headers: Headers, data: T) {\n    super(Conflict.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class Gone<T = { message: string }> extends APIError<T, 410> {\n  static override status = 410 as const;\n  constructor(headers: Headers, data: T) {\n    super(Gone.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class PreconditionFailed<T = { message: string }> extends APIError<\n  T,\n  412\n> {\n  static override status = 412 as const;\n  constructor(headers: Headers, data: T) {\n    super(PreconditionFailed.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class UnprocessableEntity<\n  T = { message: string; errors?: Record<string, string[]> },\n> extends APIError<T, 422> {\n  static override status = 422 as const;\n  constructor(headers: Headers, data: T) {\n    super(UnprocessableEntity.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class TooManyRequests<\n  T = { message: string; retryAfter?: string },\n> extends APIError<T, 429> {\n  static override status = 429 as const;\n  constructor(headers: Headers, data: T) {\n    super(TooManyRequests.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class PayloadTooLarge<T = { message: string }> extends APIError<T, 413> {\n  static override status = 413 as const;\n  constructor(headers: Headers, data: T) {\n    super(PayloadTooLarge.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class UnsupportedMediaType<T = { message: string }> extends APIError<\n  T,\n  415\n> {\n  static override status = 415 as const;\n  constructor(headers: Headers, data: T) {\n    super(UnsupportedMediaType.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\n\n// 5xx Server Errors\nexport class InternalServerError<T = { message: string }> extends APIError<\n  T,\n  500\n> {\n  static override status = 500 as const;\n  constructor(headers: Headers, data: T) {\n    super(InternalServerError.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class NotImplemented<T = { message: string }> extends APIError<T, 501> {\n  static override status = 501 as const;\n  constructor(headers: Headers, data: T) {\n    super(NotImplemented.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class BadGateway<T = { message: string }> extends APIError<T, 502> {\n  static override status = 502 as const;\n  constructor(headers: Headers, data: T) {\n    super(BadGateway.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class ServiceUnavailable<\n  T = { message: string; retryAfter?: string },\n> extends APIError<T, 503> {\n  static override status = 503 as const;\n  constructor(headers: Headers, data: T) {\n    super(ServiceUnavailable.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\nexport class GatewayTimeout<T = { message: string }> extends APIError<T, 504> {\n  static override status = 504 as const;\n  constructor(headers: Headers, data: T) {\n    super(GatewayTimeout.status, headers, data);\n  }\n  static override create<T>(status: number, headers: Headers, data: T) {\n    return new this(headers, data);\n  }\n}\n\nexport type ClientError =\n  | BadRequest<unknown>\n  | Unauthorized<unknown>\n  | PaymentRequired<unknown>\n  | Forbidden<unknown>\n  | NotFound<unknown>\n  | MethodNotAllowed<unknown>\n  | NotAcceptable<unknown>\n  | Conflict<unknown>\n  | Gone<unknown>\n  | PreconditionFailed<unknown>\n  | PayloadTooLarge<unknown>\n  | UnsupportedMediaType<unknown>\n  | UnprocessableEntity<unknown>\n  | TooManyRequests<unknown>;\n\nexport type ServerError =\n  | InternalServerError<unknown>\n  | NotImplemented<unknown>\n  | BadGateway<unknown>\n  | ServiceUnavailable<unknown>\n  | GatewayTimeout<unknown>;\n\nexport type ProblematicResponse = ClientError | ServerError;\n\nexport type SuccessfulResponse<T = unknown> =\n  | Ok<T>\n  | Created<T>\n  | Accepted<T>\n  | NoContent;\n\nexport type RebindSuccessPayload<Resp, New> =\n  Resp extends Ok<infer _>\n    ? Ok<New>\n    : Resp extends Created<infer _>\n      ? Created<New>\n      : Resp extends Accepted<infer _>\n        ? Accepted<New>\n        : Resp extends NoContent\n          ? NoContent\n          : Resp extends SuccessfulResponse<infer _>\n            ? APIResponse<New, Resp['status']>\n            : never;\n";
 
 // packages/typescript/src/lib/paginations/cursor-pagination.txt
 var cursor_pagination_default = "type CursorPaginationParams = {\n  cursor?: string;\n};\n\ninterface CursorMetadata extends Metadata {\n  nextCursor?: string;\n}\n\ninterface Metadata {\n  hasMore?: boolean;\n}\n\ntype PaginationResult<T, M extends CursorMetadata> = {\n  data: T[];\n  meta: M;\n};\n\ntype FetchFn<T, M extends CursorMetadata> = (\n  input: CursorPaginationParams,\n) => Promise<PaginationResult<T, M>>;\n\n/**\n * @experimental\n */\nexport class CursorPagination<T, M extends CursorMetadata> {\n  #meta: PaginationResult<T, M>['meta'] | null = null;\n  #params: CursorPaginationParams;\n  #currentPage: Page<T> | null = null;\n  readonly #fetchFn: FetchFn<T, M>;\n\n  constructor(\n    initialParams: PartialNullable<CursorPaginationParams>,\n    fetchFn: FetchFn<T, M>,\n  ) {\n    this.#fetchFn = fetchFn;\n    this.#params = {\n      cursor: initialParams.cursor ?? undefined,\n    };\n  }\n\n  async getNextPage() {\n    const result = await this.#fetchFn(this.#params);\n    this.#currentPage = new Page(result.data);\n    this.#meta = result.meta;\n    this.#params = {\n      ...this.#params,\n      cursor: result.meta.nextCursor,\n    };\n    return this;\n  }\n\n  getCurrentPage() {\n    if (!this.#currentPage) {\n      throw new Error(\n        'No page data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#currentPage;\n  }\n\n  get hasMore() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta.hasMore;\n  }\n\n  async *[Symbol.asyncIterator]() {\n    for await (const page of this.iter()) {\n      yield page.getCurrentPage();\n    }\n  }\n\n  async *iter() {\n    if (!this.#currentPage) {\n      yield await this.getNextPage();\n    }\n\n    while (this.hasMore) {\n      yield await this.getNextPage();\n    }\n  }\n\n  get metadata() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta;\n  }\n}\n\nclass Page<T> {\n  data: T[];\n  constructor(data: T[]) {\n    this.data = data;\n  }\n}\n\ntype PartialNullable<T> = {\n  [K in keyof T]?: T[K] | null;\n};\n";
@@ -3036,15 +2608,7 @@ async function generate(openapi, settings) {
     },
     false
   );
-  const style = Object.assign(
-    {},
-    {
-      errorAsValue: false,
-      name: "github",
-      outputType: "default"
-    },
-    settings.style ?? {}
-  );
+  const style = Object.assign({}, { name: "github" }, settings.style ?? {});
   const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   settings.useTsExtension ??= true;
   settings.readme ??= true;
@@ -3087,23 +2651,20 @@ async function generate(openapi, settings) {
 import { type Interceptor } from '${makeImport("../http/interceptors")}';
 import { type RequestConfig } from '${makeImport("../http/request")}';
 import { buffered } from '${makeImport("./parse-response")}';
-import { APIError, APIResponse, type SuccessfulResponse, type ProblematicResponse } from '${makeImport("./response")}';
+import { APIError, APIResponse, type SuccessfulResponse, type RebindSuccessPayload } from '${makeImport("./response")}';
 
-${template2(dispatcher_default, {})({ throwError: !style.errorAsValue, outputType: style.outputType })}`,
+${template2(dispatcher_default, {})()}`,
     "interceptors.ts": `
     import type { RequestConfig, HeadersInit } from './${makeImport("request")}';
     ${interceptors_default}`
   });
   await settings.writer(output, {
-    "client.ts": client_default(
-      {
-        name: clientName,
-        servers: (spec.servers ?? []).map((server) => server.url) || [],
-        options: security(spec),
-        makeImport
-      },
-      style
-    ),
+    "client.ts": client_default({
+      name: clientName,
+      servers: (spec.servers ?? []).map((server) => server.url) || [],
+      options: security(spec),
+      makeImport
+    }),
     ...inputs,
     ...endpoints
   });