@sdk-it/typescript 0.17.0 → 0.19.0

package/dist/index.js

@@ -1,12 +1,138 @@
 // packages/typescript/src/lib/generate.ts
-import { join as join2 } from "node:path";
+import { template as template2 } from "lodash-es";
+import { join as join3 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
 import { spinalcase as spinalcase3 } from "stringcase";
-import { getFolderExports, methods, writeFiles } from "@sdk-it/core";
+
+// packages/core/dist/index.js
+import {
+  pascalcase as _pascalcase,
+  snakecase as _snakecase,
+  spinalcase as _spinalcase
+} from "stringcase";
+import ts, { TypeFlags, symbolName } from "typescript";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join } from "node:path";
+import debug from "debug";
+import ts2 from "typescript";
+import { get } from "lodash-es";
+var deriveSymbol = Symbol.for("serialize");
+var $types = Symbol.for("types");
+async function exist(file) {
+  return stat(file).then(() => true).catch(() => false);
+}
+async function writeFiles(dir, contents) {
+  await Promise.all(
+    Object.entries(contents).map(async ([file, content]) => {
+      if (content === null) {
+        return;
+      }
+      const filePath = isAbsolute(file) ? file : join(dir, file);
+      await mkdir(dirname(filePath), { recursive: true });
+      if (typeof content === "string") {
+        await writeFile(filePath, content, "utf-8");
+      } else {
+        if (content.ignoreIfExists) {
+          if (!await exist(filePath)) {
+            await writeFile(filePath, content.content, "utf-8");
+          }
+        } else {
+          await writeFile(filePath, content.content, "utf-8");
+        }
+      }
+    })
+  );
+}
+async function getFolderExports(folder, includeExtension = true, extensions = ["ts"], ignore = () => false) {
+  const files = await readdir(folder, { withFileTypes: true });
+  const exports = [];
+  for (const file of files) {
+    if (ignore(file)) {
+      continue;
+    }
+    if (file.isDirectory()) {
+      if (await exist(`${file.parentPath}/${file.name}/index.ts`)) {
+        exports.push(
+          `export * from './${file.name}/index${includeExtension ? ".ts" : ""}';`
+        );
+      }
+    } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
+      exports.push(
+        `export * from './${includeExtension ? file.name : file.name.replace(extname(file.name), "")}';`
+      );
+    }
+  }
+  return exports.join("\n");
+}
+var getExt = (fileName) => {
+  if (!fileName) {
+    return "";
+  }
+  const lastDot = fileName.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  const ext = fileName.slice(lastDot + 1).split("/").filter(Boolean).join("");
+  if (ext === fileName) {
+    return "";
+  }
+  return ext || "txt";
+};
+var methods = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "trace",
+  "head"
+];
+var logger = debug("january:client");
+function isRef(obj) {
+  return obj && "$ref" in obj;
+}
+function cleanRef(ref) {
+  return ref.replace(/^#\//, "");
+}
+function parseRef(ref) {
+  const parts = ref.split("/");
+  const [model] = parts.splice(-1);
+  const [namespace] = parts.splice(-1);
+  return {
+    model,
+    namespace,
+    path: cleanRef(parts.join("/"))
+  };
+}
+function followRef(spec, ref) {
+  const pathParts = cleanRef(ref).split("/");
+  const entry = get(spec, pathParts);
+  if (entry && "$ref" in entry) {
+    return followRef(spec, entry.$ref);
+  }
+  return entry;
+}
+function removeDuplicates(data, accessor = (item) => item) {
+  return [...new Map(data.map((x) => [accessor(x), x])).values()];
+}
+function toLitObject(obj, accessor = (value) => value) {
+  return `{${Object.keys(obj).map((key) => `${key}: ${accessor(obj[key])}`).join(", ")}}`;
+}
+function isEmpty(value) {
+  if (value === null || value === void 0 || value === "") {
+    return true;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  if (typeof value === "object" && Object.keys(value).length === 0) {
+    return true;
+  }
+  return false;
+}
 
 // packages/typescript/src/lib/client.ts
-import { toLitObject } from "@sdk-it/core";
-var client_default = (spec) => {
+var client_default = (spec, style) => {
   const optionsEntries = Object.entries(spec.options).map(
     ([key, value]) => [`'${key}'`, value]
   );
@@ -28,8 +154,8 @@ var client_default = (spec) => {
     }
   };
   return `
-import type { RequestConfig } from './http/${spec.makeImport("request")}';
-import { fetchType, sendRequest, parse } from './http/${spec.makeImport("send-request")}';
+import type { HeadersInit, RequestConfig } from './http/${spec.makeImport("request")}';
+import { fetchType, dispatch, parse } from './http/${spec.makeImport("send-request")}';
 import z from 'zod';
 import type { Endpoints } from './api/${spec.makeImport("endpoints")}';
 import schemas from './api/${spec.makeImport("schemas")}';
@@ -56,9 +182,9 @@ export class ${spec.name} {
     endpoint: E,
     input: Endpoints[E]['input'],
     options?: { signal?: AbortSignal, headers?: HeadersInit },
-  ): Promise<readonly [Endpoints[E]['output'], Endpoints[E]['error'] | null]> {
+  ) ${style.errorAsValue ? `: Promise<readonly [Endpoints[E]['output'], Endpoints[E]['error'] | null]>` : `: Promise<Endpoints[E]['output']>`} {
     const route = schemas[endpoint];
-    return sendRequest(Object.assign(this.#defaultInputs, input), route, {
+    const result = await dispatch(Object.assign(this.#defaultInputs, input), route, {
       fetch: this.options.fetch,
       interceptors: [
         createHeadersInterceptor(() => this.defaultHeaders, options?.headers ?? {}),
@@ -66,20 +192,23 @@ export class ${spec.name} {
       ],
       signal: options?.signal,
     });
+    return ${style.errorAsValue ? `result as [Endpoints[E]['output'], Endpoints[E]['error'] | null]` : `result as Endpoints[E]['output']`};
   }
 
   async prepare<E extends keyof Endpoints>(
     endpoint: E,
     input: Endpoints[E]['input'],
     options?: { headers?: HeadersInit },
-  ): Promise<
+  ): ${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>;
+      }>`} {
     const route = schemas[endpoint];
 
     const interceptors = [
@@ -91,7 +220,7 @@ export class ${spec.name} {
     ];
     const [parsedInput, parseError] = parseInput(route.schema, input);
     if (parseError) {
-      return [null as never, parseError as never] as const;
+      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
     }
 
     let config = route.toRequest(parsedInput as never);
@@ -100,10 +229,8 @@ export class ${spec.name} {
         config = await interceptor.before(config);
       }
     }
-    return [
-      { ...config, parse: (response: Response) => parse(route, response) },
-      null as never,
-    ] as const;
+    const prepared = { ...config, parse: (response: Response) => parse(route, response) };
+    return ${style.errorAsValue ? "[prepared, null as never] as const;" : "prepared"}
   }
 
   get defaultHeaders() {
@@ -127,10 +254,9 @@ export class ${spec.name} {
 };
 
 // packages/typescript/src/lib/generator.ts
-import { merge } from "lodash-es";
-import { join } from "node:path";
+import { merge, template } from "lodash-es";
+import { join as join2 } from "node:path";
 import { camelcase as camelcase3, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
-import { followRef as followRef4, isEmpty, isRef as isRef5 } from "@sdk-it/core";
 
 // packages/spec/dist/lib/operation.js
 import { camelcase } from "stringcase";
@@ -395,7 +521,6 @@ function determineGenericTag(pathString, operation) {
 }
 
 // packages/typescript/src/lib/emitters/zod.ts
-import { cleanRef, followRef, isRef, parseRef } from "@sdk-it/core";
 var ZodDeserialzer = class {
   circularRefTracker = /* @__PURE__ */ new Set();
   #spec;
@@ -657,12 +782,10 @@ function appendDefault(defaultValue) {
 }
 
 // packages/typescript/src/lib/sdk.ts
-import { get } from "lodash-es";
+import { get as get2 } from "lodash-es";
 import { camelcase as camelcase2, pascalcase, spinalcase } from "stringcase";
-import { followRef as followRef3, isRef as isRef4, toLitObject as toLitObject2 } from "@sdk-it/core";
 
 // packages/typescript/src/lib/emitters/interface.ts
-import { cleanRef as cleanRef2, followRef as followRef2, isRef as isRef2, parseRef as parseRef2 } from "@sdk-it/core";
 var TypeScriptDeserialzer = class {
   circularRefTracker = /* @__PURE__ */ new Set();
   #spec;
@@ -671,70 +794,12 @@ var TypeScriptDeserialzer = class {
     this.#spec = spec;
     this.#onRef = onRef;
   }
-  #stringifyKey = (key) => {
-    const reservedWords = [
-      "constructor",
-      "prototype",
-      "break",
-      "case",
-      "catch",
-      "class",
-      "const",
-      "continue",
-      "debugger",
-      "default",
-      "delete",
-      "do",
-      "else",
-      "export",
-      "extends",
-      "false",
-      "finally",
-      "for",
-      "function",
-      "if",
-      "import",
-      "in",
-      "instanceof",
-      "new",
-      "null",
-      "return",
-      "super",
-      "switch",
-      "this",
-      "throw",
-      "true",
-      "try",
-      "typeof",
-      "var",
-      "void",
-      "while",
-      "with",
-      "yield"
-    ];
-    if (reservedWords.includes(key)) {
-      return `'${key}'`;
-    }
-    if (key.trim() === "") {
-      return `'${key}'`;
-    }
-    const firstChar = key.charAt(0);
-    const validFirstChar = firstChar >= "a" && firstChar <= "z" || firstChar >= "A" && firstChar <= "Z" || firstChar === "_" || firstChar === "$";
-    if (!validFirstChar) {
-      return `'${key.replace(/'/g, "\\'")}'`;
-    }
-    for (let i = 1; i < key.length; i++) {
-      const char = key.charAt(i);
-      const validChar = char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "_" || char === "$";
-      if (!validChar) {
-        return `'${key.replace(/'/g, "\\'")}'`;
-      }
-    }
-    return key;
-  };
-  #stringifyKeyV2 = (value) => {
+  #stringifyKey = (value) => {
     return `'${value}'`;
   };
+  #isInternal = (schema) => {
+    return isRef(schema) ? false : !!schema["x-internal"];
+  };
   /**
    * Handle objects (properties)
    */
@@ -743,7 +808,7 @@ var TypeScriptDeserialzer = class {
     const propEntries = Object.entries(properties).map(([key, propSchema]) => {
       const isRequired = (schema.required ?? []).includes(key);
       const tsType = this.handle(propSchema, isRequired);
-      return `${this.#stringifyKeyV2(key)}: ${tsType}`;
+      return `${this.#isInternal(propSchema) ? key : this.#stringifyKey(key)}: ${tsType}`;
     });
     if (schema.additionalProperties) {
       if (typeof schema.additionalProperties === "object") {
@@ -794,14 +859,14 @@ var TypeScriptDeserialzer = class {
     }
   }
   ref($ref, required) {
-    const schemaName = cleanRef2($ref).split("/").pop();
+    const schemaName = cleanRef($ref).split("/").pop();
     if (this.circularRefTracker.has(schemaName)) {
       return schemaName;
     }
     this.circularRefTracker.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef2(this.#spec, $ref), required)
+      this.handle(followRef(this.#spec, $ref), required)
     );
     this.circularRefTracker.delete(schemaName);
     return appendOptional2(schemaName, required);
@@ -819,8 +884,8 @@ var TypeScriptDeserialzer = class {
   }
   oneOf(schemas, required) {
     const oneOfTypes = schemas.map((sub) => {
-      if (isRef2(sub)) {
-        const { model } = parseRef2(sub.$ref);
+      if (isRef(sub)) {
+        const { model } = parseRef(sub.$ref);
         if (this.circularRefTracker.has(model)) {
           return model;
         }
@@ -867,7 +932,7 @@ var TypeScriptDeserialzer = class {
     return appendOptional2(type, required);
   }
   handle(schema, required) {
-    if (isRef2(schema)) {
+    if (isRef(schema)) {
       return this.ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -882,6 +947,12 @@ var TypeScriptDeserialzer = class {
     if (schema.enum && Array.isArray(schema.enum)) {
       return this.enum(schema.enum, required);
     }
+    if (schema.const) {
+      if (schema["x-internal"]) {
+        return `${schema.const}`;
+      }
+      return this.enum([schema.const], required);
+    }
     const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
     if (!types.length) {
       if ("properties" in schema) {
@@ -900,20 +971,12 @@ var TypeScriptDeserialzer = class {
     }
     return this.normal(types[0], schema, required);
   }
-  /**
-   * Generate an interface declaration
-   */
-  generateInterface(name, schema) {
-    const content = this.handle(schema, true);
-    return `interface ${name} ${content}`;
-  }
 };
 function appendOptional2(type, isRequired) {
   return isRequired ? type : `${type} | undefined`;
 }
 
 // packages/typescript/src/lib/utils.ts
-import { isRef as isRef3, removeDuplicates } from "@sdk-it/core";
 function securityToOptions(security2, securitySchemes, staticIn) {
   securitySchemes ??= {};
   const options = {};
@@ -923,7 +986,7 @@ function securityToOptions(security2, securitySchemes, staticIn) {
       continue;
     }
     const schema = securitySchemes[name];
-    if (isRef3(schema)) {
+    if (isRef(schema)) {
       throw new Error(`Ref security schemas are not supported`);
     }
     if (schema.type === "http") {
@@ -1012,7 +1075,7 @@ function generateInputs(operationsSet, commonZod, makeImport) {
     const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
     for (const operation of operations) {
       const schemaName = camelcase2(`${operation.name} schema`);
-      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject2(operation.schemas)};`;
+      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject(operation.schemas)};`;
       const inputContent = schema;
       for (const schema2 of commonImports) {
         if (inputContent.includes(schema2)) {
@@ -1082,7 +1145,7 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
     return statusCode >= 200 && statusCode < 300;
   }).length > 1;
   for (const status in specOperation.responses) {
-    const response = isRef4(specOperation.responses[status]) ? followRef3(spec, specOperation.responses[status].$ref) : specOperation.responses[status];
+    const response = isRef(specOperation.responses[status]) ? followRef(spec, specOperation.responses[status].$ref) : specOperation.responses[status];
     const handled = handleResponse(
       spec,
       operation.name,
@@ -1172,7 +1235,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
   );
   const statusCode = +status;
   const parser = (response.headers ?? {})["Transfer-Encoding"] ? "chunked" : "buffered";
-  const statusName = statusCodeToResponseMap[status] || "APIResponse";
+  const statusName = `http.${statusCodeToResponseMap[status] || "APIResponse"}`;
   const interfaceName = pascalcase(
     operationName + ` output${numbered ? status : ""}`
   );
@@ -1180,22 +1243,34 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
     outputs.push(statusName);
   } else {
     if (status.endsWith("XX")) {
-      outputs.push(`APIError<${interfaceName}>`);
+      outputs.push(`http.APIError<${interfaceName}>`);
     } else {
       outputs.push(
         parser !== "buffered" ? `{type: ${statusName}<${interfaceName}>, parser: ${parser}}` : `${statusName}<${interfaceName}>`
       );
     }
   }
-  const responseContent = get(response, ["content"]);
+  const responseContent = get2(response, ["content"]);
   const isJson = responseContent && responseContent["application/json"];
-  const responseSchema = isJson ? typeScriptDeserialzer.handle(
-    responseContent["application/json"].schema,
-    true
-  ) : "void";
+  let responseSchema = parser === "chunked" ? "ReadableStream" : "void";
+  if (isJson) {
+    const schema = responseContent["application/json"].schema;
+    const isObject = !isRef(schema) && schema.type === "object";
+    if (isObject && schema.properties) {
+      schema.properties["[http.KIND]"] = {
+        "x-internal": true,
+        const: `typeof ${statusName}.kind`,
+        type: "string"
+      };
+      schema.required ??= [];
+      schema.required.push("[KIND]");
+    }
+    responseSchema = typeScriptDeserialzer.handle(schema, true);
+  }
   responses.push({
     name: interfaceName,
-    schema: responseSchema
+    schema: responseSchema,
+    description: response.description
   });
   const statusGroup = +status.slice(0, 1);
   if (statusCode >= 400 || statusGroup >= 4) {
@@ -1209,15 +1284,6 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
       namedImports: [{ isTypeOnly: true, name: interfaceName }]
     };
   } else if (statusCode >= 200 && statusCode < 300 || statusCode >= 2 || statusGroup <= 3) {
-    endpointImports[statusName] = {
-      moduleSpecifier: utils.makeImport("../http/response"),
-      namedImports: [
-        {
-          isTypeOnly: false,
-          name: statusName
-        }
-      ]
-    };
     endpointImports[interfaceName] = {
       defaultImport: void 0,
       isTypeOnly: true,
@@ -1230,7 +1296,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
 }
 
 // packages/typescript/src/lib/styles/github/endpoints.txt
-var endpoints_default = "\ntype Output<T extends OutputType> = T extends {\n  parser: Parser;\n  type: Type<unknown>;\n}\n  ? InstanceType<T['type']>\n  : T extends Type<unknown>\n    ? InstanceType<T>\n    : never;\n\ntype Unionize<T> = T extends [infer Single extends OutputType]\n  ? Output<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: Output<Tuple[I]> }[number]\n    : never;\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  [K in keyof typeof schemas]: {\n    input: z.infer<(typeof schemas)[K]['schema']>;\n    output: EndpointOutput<K>;\n    error: EndpointError<K> | ParseError<(typeof schemas)[K]['schema']>;\n  };\n};";
+var endpoints_default = "type Output<T extends OutputType> = T extends {\n  parser: Parser;\n  type: Type<unknown>;\n}\n  ? InstanceType<T['type']>\n  : T extends Type<unknown>\n    ? InstanceType<T>\n    : never;\n\ntype Unionize<T> = T extends [infer Single extends OutputType]\n  ? Output<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: Output<Tuple[I]> }[number]\n    : never;\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  [K in keyof typeof schemas]: {\n    input: z.infer<(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};";
 
 // packages/typescript/src/lib/generator.ts
 function generateCode(config) {
@@ -1256,7 +1322,7 @@ function generateCode(config) {
     const inputs = {};
     const additionalProperties = [];
     for (const param of operation.parameters ?? []) {
-      if (isRef5(param)) {
+      if (isRef(param)) {
         throw new Error(`Found reference in parameter ${param.$ref}`);
       }
       if (!param.schema) {
@@ -1298,9 +1364,9 @@ function generateCode(config) {
     };
     let outgoingContentType;
     if (!isEmpty(operation.requestBody)) {
-      const requestBody = isRef5(operation.requestBody) ? followRef4(config.spec, operation.requestBody.$ref) : operation.requestBody;
+      const requestBody = isRef(operation.requestBody) ? followRef(config.spec, operation.requestBody.$ref) : operation.requestBody;
       for (const type in requestBody.content) {
-        const ctSchema = isRef5(requestBody.content[type].schema) ? followRef4(config.spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
+        const ctSchema = isRef(requestBody.content[type].schema) ? followRef(config.spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
         if (!ctSchema) {
           console.warn(
             `Schema not found for ${type} in ${entry.method} ${entry.path}`
@@ -1370,14 +1436,23 @@ function generateCode(config) {
       },
       { makeImport: config.makeImport }
     );
-    const output = [`import z from 'zod';`];
+    const output = [
+      `import z from 'zod';`,
+      `import type * as http from '../http';`
+    ];
     const responses = endpoint.responses.flatMap((it) => it.responses);
     const responsesImports = endpoint.responses.flatMap(
       (it) => Object.values(it.imports)
     );
     if (responses.length) {
       output.push(
-        ...responses.map((it) => `export type ${it.name} = ${it.schema};`)
+        ...responses.map(
+          (it) => `${it.description ? `
+/** 
+ * ${it.description}
+ */
+` : ""} export type ${it.name} = ${it.schema};`
+        )
       );
     } else {
       output.push(
@@ -1428,7 +1503,7 @@ function generateCode(config) {
     commonZod,
     outputs,
     endpoints: {
-      [join("api", "endpoints.ts")]: `
+      [join2("api", "endpoints.ts")]: `
 
 
 import type z from 'zod';
@@ -1442,9 +1517,9 @@ import type { OutputType, Parser, Type } from '${config.makeImport(
 
 import schemas from '${config.makeImport("./schemas")}';
 
-      ${endpoints_default}`,
-      [`${join("api", "schemas.ts")}`]: `${allSchemas.map((it) => it.import).join("\n")}
-
+      ${template(endpoints_default)({ outputType: config.style?.outputType })}`,
+      [`${join2("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")}
 };
@@ -1463,11 +1538,12 @@ ${allSchemas.map((it) => it.use).join(",\n")}
           );
           return [
             [
-              join("api", `${spinalcase2(name)}.ts`),
+              join2("api", `${spinalcase2(name)}.ts`),
               `${[
                 ...imps,
                 // ...imports,
                 `import z from 'zod';`,
+                `import * as http from '${config.makeImport("../http/response")}';`,
                 `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${config.makeImport("../http/request")}';`,
                 `import { chunked, buffered } from "${config.makeImport("../http/parse-response")}";`,
                 `import * as ${camelcase3(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`
@@ -1485,8 +1561,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef5(schemaOrRef)) {
-    const schema = followRef4(spec, schemaOrRef.$ref);
+  if (isRef(schemaOrRef)) {
+    const schema = followRef(spec, schemaOrRef.$ref);
     return toProps(spec, schema, aggregator);
   } else if (schemaOrRef.type === "object") {
     for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
@@ -1531,7 +1607,7 @@ function bodyInputs(config, ctSchema) {
 }
 
 // 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  defaultHeaders: () => 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      const headers = defaultHeaders();\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 = (\n  getBaseUrl: () => string,\n): Interceptor => {\n  return {\n    before({ init, url }) {\n      const baseUrl = getBaseUrl();\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.dir('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";
+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  defaultHeaders: () => 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      const headers = defaultHeaders();\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 = (\n  getBaseUrl: () => string,\n): Interceptor => {\n  return {\n    before({ init, url }) {\n      const baseUrl = getBaseUrl();\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";
 
 // packages/typescript/src/lib/http/parse-response.txt
 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';
@@ -1540,13 +1616,421 @@ var parse_response_default = 'import { parse } from "fast-content-type-parse";\n
 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";
 
 // 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 = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart' | 'formdata';\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\nexport function createUrl(path: string, query: URLSearchParams) {\n  const url = new URL(path, `local://`);\n  url.search = query.toString();\n  return url;\n}\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(\n    input: Input,\n    props: Props,\n  ) {\n    this.input = input;\n    this.props = props;\n  }\n\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Record<string, string>;\n  serialize(): Serialized {\n    const headers = new Headers({});\n    for (const header of this.props.inputHeaders) {\n      headers.set(header, this.input[header]);\n    }\n\n    const query = new URLSearchParams();\n    for (const key of this.props.inputQuery) {\n      const value = this.input[key];\n      if (value !== undefined) {\n        query.set(key, String(value));\n      }\n    }\n\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\n    return {\n      body: this.getBody(),\n      query,\n      params,\n      headers: this.getHeaders(),\n    };\n  }\n}\n\ninterface Serialized {\n  body: BodyInit | null;\n  query: URLSearchParams;\n  params: Record<string, any>;\n  headers: Record<string, string>;\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 NoBodySerializer 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).serialize();\n}\nexport function urlencoded(input: Input, props: Props) {\n  return new UrlencodedSerializer(input, props).serialize();\n}\nexport function nobody(input: Input, props: Props) {\n  return new NoBodySerializer(input, props).serialize();\n}\nexport function formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n): RequestConfig {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  return {\n    url: createUrl(pathVariable, input.query),\n    init: {\n      method: method,\n      headers: new Headers(input.headers),\n      body: method === 'GET' ? undefined : input.body,\n    },\n  }\n}\n";
+var request_default = "type Init = Omit<RequestInit, 'headers'> & { headers: Headers; };\nexport type RequestConfig = { init: Init; url: URL };\nexport type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart' | '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\nexport function createUrl(path: string, query: URLSearchParams) {\n  const url = new URL(path, `local://`);\n  url.search = query.toString();\n  return url;\n}\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(\n    input: Input,\n    props: Props,\n  ) {\n    this.input = input;\n    this.props = props;\n  }\n\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Record<string, string>;\n  serialize(): Serialized {\n    const headers = new Headers({});\n    for (const header of this.props.inputHeaders) {\n      headers.set(header, this.input[header]);\n    }\n\n    const query = new URLSearchParams();\n    for (const key of this.props.inputQuery) {\n      const value = this.input[key];\n      if (value !== undefined) {\n        query.set(key, String(value));\n      }\n    }\n\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\n    return {\n      body: this.getBody(),\n      query,\n      params,\n      headers: this.getHeaders(),\n    };\n  }\n}\n\ninterface Serialized {\n  body: BodyInit | null;\n  query: URLSearchParams;\n  params: Record<string, any>;\n  headers: Record<string, string>;\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 NoBodySerializer 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).serialize();\n}\nexport function urlencoded(input: Input, props: Props) {\n  return new UrlencodedSerializer(input, props).serialize();\n}\nexport function nobody(input: Input, props: Props) {\n  return new NoBodySerializer(input, props).serialize();\n}\nexport function formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n): RequestConfig {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  return {\n    url: createUrl(pathVariable, input.query),\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 class APIResponse<Body = unknown, Status extends number = number> {\n  static status: number;\n  status: Status;\n  data: Body;\n\n  constructor(status: Status, data: Body) {\n    this.status = status;\n    this.data = data;\n  }\n\n  static create<Body = unknown>(status: number, data: Body) {\n    return new this(status, 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, data: T) {\n    return new this(status, data);\n  }\n}\n\n// 2xx Success\nexport class Ok<T> extends APIResponse<T, 200> {\n  static override status = 200 as const;\n  constructor(data: T) {\n    super(Ok.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class Created<T> extends APIResponse<T, 201> {\n  static override status = 201 as const;\n  constructor(data: T) {\n    super(Created.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class Accepted<T> extends APIResponse<T, 202> {\n  static override status = 202 as const;\n  constructor(data: T) {\n    super(Accepted.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class NoContent extends APIResponse<never, 204> {\n  static override status = 204 as const;\n  constructor() {\n    super(NoContent.status, null as never);\n  }\n  static override create(status: number, data: never): NoContent {\n    return new this();\n  }\n}\n\n// 4xx Client Errors\nexport class BadRequest<T> extends APIError<T, 400> {\n  static override status = 400 as const;\n  constructor(data: T) {\n    super(BadRequest.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class Unauthorized<T = { message: string }> extends APIError<T, 401> {\n  static override status = 401 as const;\n  constructor(data: T) {\n    super(Unauthorized.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class PaymentRequired<T = { message: string }> extends APIError<T, 402> {\n  static override status = 402 as const;\n  constructor(data: T) {\n    super(PaymentRequired.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class Forbidden<T = { message: string }> extends APIError<T, 403> {\n  static override status = 403 as const;\n  constructor(data: T) {\n    super(Forbidden.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class NotFound<T = { message: string }> extends APIError<T, 404> {\n  static override status = 404 as const;\n  constructor(data: T) {\n    super(NotFound.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(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(data: T) {\n    super(MethodNotAllowed.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class NotAcceptable<T = { message: string }> extends APIError<T, 406> {\n  static override status = 406 as const;\n  constructor(data: T) {\n    super(NotAcceptable.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class Conflict<T = { message: string }> extends APIError<T, 409> {\n  static override status = 409 as const;\n  constructor(data: T) {\n    super(Conflict.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class Gone<T = { message: string }> extends APIError<T, 410> {\n  static override status = 410 as const;\n  constructor(data: T) {\n    super(Gone.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(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(data: T) {\n    super(UnprocessableEntity.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(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(data: T) {\n    super(TooManyRequests.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class PayloadTooLarge<T = { message: string }> extends APIError<T, 413> {\n  static override status = 413 as const;\n  constructor(data: T) {\n    super(PayloadTooLarge.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(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(data: T) {\n    super(UnsupportedMediaType.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(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(data: T) {\n    super(InternalServerError.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class NotImplemented<T = { message: string }> extends APIError<T, 501> {\n  static override status = 501 as const;\n  constructor(data: T) {\n    super(NotImplemented.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class BadGateway<T = { message: string }> extends APIError<T, 502> {\n  static override status = 502 as const;\n  constructor(data: T) {\n    super(BadGateway.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(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(data: T) {\n    super(ServiceUnavailable.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\nexport class GatewayTimeout<T = { message: string }> extends APIError<T, 504> {\n  static override status = 504 as const;\n  constructor(data: T) {\n    super(GatewayTimeout.status, data);\n  }\n  static override create<T>(status: number, data: T) {\n    return new this(data);\n  }\n}\n\nexport type ClientError =\n  | BadRequest<{ message: string }>\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  | 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 = Ok<unknown> | Created<unknown> | Accepted<unknown> | NoContent;";
+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 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<{ message: string }>
+  | Unauthorized<unknown>
+  | PaymentRequired<unknown>
+  | Forbidden<unknown>
+  | NotFound<unknown>
+  | MethodNotAllowed<unknown>
+  | NotAcceptable<unknown>
+  | Conflict<unknown>
+  | Gone<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;
+`;
 
 // packages/typescript/src/lib/http/send-request.txt
-var send_request_default = "export 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 interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => RequestConfig;\n  output: OutputType[];\n}\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 sendRequest(\n  input: unknown,\n  route: RequestSchema,\n  options: {\n    fetch?: z.infer<typeof fetchType>;\n    interceptors?: Interceptor[];\n    signal?: AbortSignal;\n  },\n) {\n  const { interceptors = [] } = options;\n  const [parsedInput, parseError] = parseInput(route.schema, input);\n  if (parseError) {\n    return [null as never, parseError as never] as const;\n  }\n\n  let config = route.toRequest(parsedInput as never);\n  for (const interceptor of interceptors) {\n    if (interceptor.before) {\n      config = await interceptor.before(config);\n    }\n  }\n\n  let response = await (options.fetch ?? fetch)(\n    new Request(config.url, config.init),\n    {\n      ...config.init,\n      signal: options.signal,\n    },\n  );\n\n  for (let i = interceptors.length - 1; i >= 0; i--) {\n    const interceptor = interceptors[i];\n    if (interceptor.after) {\n      response = await interceptor.after(response.clone());\n    }\n  }\n  return await parse(route, response);\n}\n\nexport async function parse(route: RequestSchema, response: Response) {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of route.output) {\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 data = (output || APIResponse).create(\n      response.status,\n      await parser(response),\n    );\n    return [data as never, null] as const;\n  }\n  const data = (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n  return [null as never, data as never] as const;\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";
+var send_request_default = "export 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 interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => RequestConfig;\n  output: OutputType[];\n}\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 dispatch(\n  input: unknown,\n  route: RequestSchema,\n  options: {\n    fetch?: z.infer<typeof fetchType>;\n    interceptors?: Interceptor[];\n    signal?: AbortSignal;\n  },\n) {\n  const { interceptors = [] } = options;\n  const [parsedInput, parseError] = parseInput(route.schema, input);\n  if (parseError) {\n    <% if(throwError) { %>\n      throw parseError;\n    <% } else { %>\n      return [null as never, parseError as never] as const;\n    <% } %>\n  }\n\n  let config = route.toRequest(parsedInput as never);\n  for (const interceptor of interceptors) {\n    if (interceptor.before) {\n      config = await interceptor.before(config);\n    }\n  }\n\n  let response = await (options.fetch ?? fetch)(\n    new Request(config.url, config.init),\n    {\n      ...config.init,\n      signal: options.signal,\n    },\n  );\n\n  for (let i = interceptors.length - 1; i >= 0; i--) {\n    const interceptor = interceptors[i];\n    if (interceptor.after) {\n      response = await interceptor.after(response.clone());\n    }\n  }\n  return await parse(route, response);\n}\n\nexport async function parse(route: RequestSchema, response: Response) {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of route.output) {\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      await parser(response),\n    );\n    <% if(throwError) { %>\n      return <% if (outputType === 'default') { %>apiresponse.data<% } else { %>apiresponse<% } %>;\n    <% } else { %>\n      return [<% if (outputType === 'default') { %>apiresponse.data<% } else { %>apiresponse<% } %> , 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 as never, data as never] 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";
 
 // packages/typescript/src/lib/generate.ts
 function security(spec) {
@@ -1570,6 +2054,15 @@ function security(spec) {
   return options;
 }
 async function generate(spec, settings) {
+  const style = Object.assign(
+    {},
+    {
+      errorAsValue: true,
+      name: "github",
+      outputType: "default"
+    },
+    settings.style ?? {}
+  );
   settings.useTsExtension ??= true;
   const makeImport = (moduleSpecifier) => {
     return settings.useTsExtension ? `${moduleSpecifier}.ts` : moduleSpecifier;
@@ -1577,11 +2070,11 @@ async function generate(spec, settings) {
   const { commonSchemas, endpoints, groups, outputs, commonZod } = generateCode(
     {
       spec,
-      style: "github",
+      style,
       makeImport
     }
   );
-  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
+  const output = settings.mode === "full" ? join3(settings.output, "src") : settings.output;
   const options = security(spec);
   const clientName = settings.name || "Client";
   const inputFiles = generateInputs(groups, commonZod, makeImport);
@@ -1591,9 +2084,9 @@ async function generate(spec, settings) {
     "models/.getkeep": ""
     // 'README.md': readme,
   });
-  await writeFiles(join2(output, "http"), {
+  await writeFiles(join3(output, "http"), {
     "interceptors.ts": `
-    import { type RequestConfig } from './${makeImport("request")}';
+    import type { RequestConfig, HeadersInit } from './${makeImport("request")}';
     ${interceptors_default}`,
     "parse-response.ts": parse_response_default,
     "send-request.ts": `import z from 'zod';
@@ -1603,20 +2096,23 @@ import { parseInput } from './${makeImport("parser")}';
 import type { RequestConfig } from './${makeImport("request")}';
 import { APIError, APIResponse } from './${makeImport("response")}';
 
-${send_request_default}`,
+${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputType: style.outputType })}`,
     "response.ts": response_default,
     "parser.ts": parser_default,
     "request.ts": request_default
   });
-  await writeFiles(join2(output, "outputs"), outputs);
+  await writeFiles(join3(output, "outputs"), outputs);
   const modelsImports = Object.entries(commonSchemas).map(([name]) => name);
   await writeFiles(output, {
-    "client.ts": client_default({
-      name: clientName,
-      servers: (spec.servers ?? []).map((server) => server.url) || [],
-      options,
-      makeImport
-    }),
+    "client.ts": client_default(
+      {
+        name: clientName,
+        servers: (spec.servers ?? []).map((server) => server.url) || [],
+        options,
+        makeImport
+      },
+      style
+    ),
     ...inputFiles,
     ...endpoints,
     ...Object.fromEntries(
@@ -1633,24 +2129,24 @@ ${send_request_default}`,
     )
   });
   const folders = [
-    getFolderExports(join2(output, "outputs"), settings.useTsExtension),
+    getFolderExports(join3(output, "outputs"), settings.useTsExtension),
     getFolderExports(
-      join2(output, "inputs"),
+      join3(output, "inputs"),
       settings.useTsExtension,
       ["ts"],
       (dirent) => dirent.isDirectory() && ["schemas"].includes(dirent.name)
     ),
-    getFolderExports(join2(output, "api"), settings.useTsExtension),
+    getFolderExports(join3(output, "api"), settings.useTsExtension),
     getFolderExports(
-      join2(output, "http"),
+      join3(output, "http"),
       settings.useTsExtension,
       ["ts"],
-      (dirent) => dirent.name !== "response.ts"
+      (dirent) => !["response.ts", "parser.ts"].includes(dirent.name)
     )
   ];
   if (modelsImports.length) {
     folders.push(
-      getFolderExports(join2(output, "models"), settings.useTsExtension)
+      getFolderExports(join3(output, "models"), settings.useTsExtension)
     );
   }
   const [outputIndex, inputsIndex, apiIndex, httpIndex, modelsIndex] = await Promise.all(folders);