@sdk-it/typescript 0.16.0 → 0.18.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // packages/typescript/src/lib/generate.ts
+import { template } from "lodash-es";
 import { join as join2 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
 import { spinalcase as spinalcase3 } from "stringcase";
@@ -6,7 +7,7 @@ import { getFolderExports, methods, writeFiles } from "@sdk-it/core";
 
 // packages/typescript/src/lib/client.ts
 import { toLitObject } from "@sdk-it/core";
-var client_default = (spec) => {
+var client_default = (spec, throwError) => {
   const optionsEntries = Object.entries(spec.options).map(
     ([key, value]) => [`'${key}'`, value]
   );
@@ -28,15 +29,18 @@ var client_default = (spec) => {
     }
   };
   return `
-import { fetchType, sendRequest } from './http/${spec.makeImport("send-request")}';
+import type { RequestConfig } from './http/${spec.makeImport("request")}';
+import { fetchType, sendRequest, parse } from './http/${spec.makeImport("send-request")}';
 import z from 'zod';
-import type { Endpoints } from './api/${spec.makeImport("schemas")}';
+import type { Endpoints } from './api/${spec.makeImport("endpoints")}';
 import schemas from './api/${spec.makeImport("schemas")}';
 import {
   createBaseUrlInterceptor,
   createHeadersInterceptor,
 } from './http/${spec.makeImport("interceptors")}';
 
+import { parseInput, type ParseError } from './http/${spec.makeImport("parser")}';
+
 ${spec.servers.length ? `export const servers = ${JSON.stringify(spec.servers, null, 2)} as const` : ""}
 const optionsSchema = z.object(${toLitObject(specOptions, (x) => x.schema)});
 ${spec.servers.length ? `export type Servers = typeof servers[number];` : ""}
@@ -53,7 +57,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]> {
+  )
+ ${throwError ? `: Endpoints[E]['output']` : `: Promise<readonly [Endpoints[E]['output'], Endpoints[E]['error'] | null]>`}
+  {
     const route = schemas[endpoint];
     return sendRequest(Object.assign(this.#defaultInputs, input), route, {
       fetch: this.options.fetch,
@@ -65,6 +71,44 @@ export class ${spec.name} {
     });
   }
 
+  async prepare<E extends keyof Endpoints>(
+    endpoint: E,
+    input: Endpoints[E]['input'],
+    options?: { headers?: HeadersInit },
+  ): Promise<
+    readonly [
+      RequestConfig & {
+        parse: (response: Response) => ReturnType<typeof parse>;
+      },
+      ParseError<(typeof schemas)[E]['schema']> | null,
+    ]
+  > {
+    const route = schemas[endpoint];
+
+    const interceptors = [
+      createHeadersInterceptor(
+        () => this.defaultHeaders,
+        options?.headers ?? {},
+      ),
+      createBaseUrlInterceptor(() => this.options.baseUrl),
+    ];
+    const [parsedInput, parseError] = parseInput(route.schema, input);
+    if (parseError) {
+      return [null as never, parseError as never] as const;
+    }
+
+    let config = route.toRequest(parsedInput as never);
+    for (const interceptor of interceptors) {
+      if (interceptor.before) {
+        config = await interceptor.before(config);
+      }
+    }
+    return [
+      { ...config, parse: (response: Response) => parse(route, response) },
+      null as never,
+    ] as const;
+  }
+
   get defaultHeaders() {
     return ${defaultHeaders}
   }
@@ -86,10 +130,272 @@ export class ${spec.name} {
 };
 
 // packages/typescript/src/lib/generator.ts
-import { get as get2, merge } from "lodash-es";
+import { merge } from "lodash-es";
 import { join } from "node:path";
-import { camelcase as camelcase2, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
-import { followRef as followRef4, forEachOperation, isRef as isRef5 } from "@sdk-it/core";
+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";
+var defaults = {
+  operationId: (operation, path, method) => {
+    if (operation.operationId) {
+      return camelcase(operation.operationId);
+    }
+    const metadata = operation["x-oaiMeta"];
+    if (metadata && metadata.name) {
+      return camelcase(metadata.name);
+    }
+    return camelcase(
+      [method, ...path.replace(/[\\/\\{\\}]/g, " ").split(" ")].filter(Boolean).join(" ").trim()
+    );
+  },
+  tag: (operation, path) => {
+    return operation.tags?.[0] || determineGenericTag(path, operation);
+  }
+};
+function forEachOperation(config, callback) {
+  const result = [];
+  for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
+    const { parameters = [], ...methods2 } = pathItem;
+    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
+    for (const [method, operation] of Object.entries(methods2)) {
+      const formatOperationId = config.operationId ?? defaults.operationId;
+      const formatTag = config.tag ?? defaults.tag;
+      const operationName = formatOperationId(operation, fixedPath, method);
+      const operationTag = formatTag(operation, fixedPath);
+      const metadata = operation["x-oaiMeta"] ?? {};
+      result.push(
+        callback(
+          {
+            name: metadata.name,
+            method,
+            path: fixedPath,
+            groupName: operationTag,
+            tag: operationTag
+          },
+          {
+            ...operation,
+            parameters: [...parameters, ...operation.parameters ?? []],
+            operationId: operationName
+          }
+        )
+      );
+    }
+  }
+  return result;
+}
+var reservedKeywords = /* @__PURE__ */ new Set([
+  "abstract",
+  "arguments",
+  "await",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  // Potentially problematic identifiers / Common Verbs used as tags
+  "object",
+  "string",
+  "number",
+  "any",
+  "unknown",
+  "never",
+  "get",
+  "list",
+  "create",
+  "update",
+  "delete",
+  "post",
+  "put",
+  "patch",
+  "do",
+  "send",
+  "add",
+  "remove",
+  "set",
+  "find",
+  "search",
+  "check",
+  "make"
+  // Added make, check
+]);
+function sanitizeTag(camelCasedTag) {
+  if (/^\d/.test(camelCasedTag)) {
+    return `_${camelCasedTag}`;
+  }
+  return reservedKeywords.has(camelCasedTag) ? `${camelCasedTag}_` : camelCasedTag;
+}
+function determineGenericTag(pathString, operation) {
+  const operationId = operation.operationId || "";
+  const VERSION_REGEX = /^[vV]\d+$/;
+  const commonVerbs = /* @__PURE__ */ new Set([
+    // Verbs to potentially strip from operationId prefix
+    "get",
+    "list",
+    "create",
+    "update",
+    "delete",
+    "post",
+    "put",
+    "patch",
+    "do",
+    "send",
+    "add",
+    "remove",
+    "set",
+    "find",
+    "search",
+    "check",
+    "make"
+    // Added make
+  ]);
+  const segments = pathString.split("/").filter(Boolean);
+  const potentialCandidates = segments.filter(
+    (segment) => segment && !segment.startsWith("{") && !segment.endsWith("}") && !VERSION_REGEX.test(segment)
+  );
+  for (let i = potentialCandidates.length - 1; i >= 0; i--) {
+    const segment = potentialCandidates[i];
+    if (!segment.startsWith("@")) {
+      return sanitizeTag(camelcase(segment));
+    }
+  }
+  const canFallbackToPathSegment = potentialCandidates.length > 0;
+  if (operationId) {
+    const lowerOpId = operationId.toLowerCase();
+    const parts = operationId.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").replace(/([a-zA-Z])(\d)/g, "$1_$2").replace(/(\d)([a-zA-Z])/g, "$1_$2").toLowerCase().split(/[_-\s]+/);
+    const validParts = parts.filter(Boolean);
+    if (commonVerbs.has(lowerOpId) && validParts.length === 1 && canFallbackToPathSegment) {
+    } else if (validParts.length > 0) {
+      const firstPart = validParts[0];
+      const isFirstPartVerb = commonVerbs.has(firstPart);
+      if (isFirstPartVerb && validParts.length > 1) {
+        const verbPrefixLength = firstPart.length;
+        let nextPartStartIndex = -1;
+        if (operationId.length > verbPrefixLength) {
+          const charAfterPrefix = operationId[verbPrefixLength];
+          if (charAfterPrefix >= "A" && charAfterPrefix <= "Z") {
+            nextPartStartIndex = verbPrefixLength;
+          } else if (charAfterPrefix >= "0" && charAfterPrefix <= "9") {
+            nextPartStartIndex = verbPrefixLength;
+          } else if (["_", "-"].includes(charAfterPrefix)) {
+            nextPartStartIndex = verbPrefixLength + 1;
+          } else {
+            const match = operationId.substring(verbPrefixLength).match(/[A-Z0-9]/);
+            if (match && match.index !== void 0) {
+              nextPartStartIndex = verbPrefixLength + match.index;
+            }
+            if (nextPartStartIndex === -1 && operationId.length > verbPrefixLength) {
+              nextPartStartIndex = verbPrefixLength;
+            }
+          }
+        }
+        if (nextPartStartIndex !== -1 && nextPartStartIndex < operationId.length) {
+          const remainingOriginalSubstring = operationId.substring(nextPartStartIndex);
+          const potentialTag = camelcase(remainingOriginalSubstring);
+          if (potentialTag) {
+            return sanitizeTag(potentialTag);
+          }
+        }
+        const potentialTagJoined = camelcase(validParts.slice(1).join("_"));
+        if (potentialTagJoined) {
+          return sanitizeTag(potentialTagJoined);
+        }
+      }
+      const potentialTagFull = camelcase(operationId);
+      if (potentialTagFull) {
+        const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;
+        if (!(isResultSingleVerb && canFallbackToPathSegment)) {
+          if (potentialTagFull.length > 0) {
+            return sanitizeTag(potentialTagFull);
+          }
+        }
+      }
+      const firstPartCamel = camelcase(firstPart);
+      if (firstPartCamel) {
+        const isFirstPartCamelVerb = commonVerbs.has(firstPartCamel);
+        if (!isFirstPartCamelVerb || validParts.length === 1 || !canFallbackToPathSegment) {
+          return sanitizeTag(firstPartCamel);
+        }
+      }
+      if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
+        const secondPartCamel = camelcase(validParts[1]);
+        if (secondPartCamel) {
+          return sanitizeTag(secondPartCamel);
+        }
+      }
+    }
+  }
+  if (potentialCandidates.length > 0) {
+    let firstCandidate = potentialCandidates[0];
+    if (firstCandidate.startsWith("@")) {
+      firstCandidate = firstCandidate.substring(1);
+    }
+    if (firstCandidate) {
+      return sanitizeTag(camelcase(firstCandidate));
+    }
+  }
+  console.warn(
+    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
+  );
+  return "unknown";
+}
 
 // packages/typescript/src/lib/emitters/zod.ts
 import { cleanRef, followRef, isRef, parseRef } from "@sdk-it/core";
@@ -218,10 +524,13 @@ var ZodDeserialzer = class {
     }
     return `z.union([${oneOfSchemas.join(", ")}])${appendOptional(required)}`;
   }
-  enum(values) {
+  enum(type, values) {
     if (values.length === 1) {
       return `z.literal(${values.join(", ")})`;
     }
+    if (type === "integer") {
+      return `z.union([${values.map((val) => `z.literal(${val})`).join(", ")}])`;
+    }
     return `z.enum([${values.join(", ")}])`;
   }
   /**
@@ -261,7 +570,7 @@ var ZodDeserialzer = class {
         break;
       case "byte":
       case "binary":
-        base = "z.instanceof(Blob) /* consider base64 check if needed */";
+        base = "z.instanceof(Blob)";
         break;
       case "int64":
         base = "z.string() /* or z.bigint() if your app can handle it */";
@@ -321,7 +630,7 @@ var ZodDeserialzer = class {
     if (schema.enum && Array.isArray(schema.enum)) {
       const enumVals = schema.enum.map((val) => JSON.stringify(val));
       const defaultValue = enumVals.includes(JSON.stringify(schema.default)) ? JSON.stringify(schema.default) : void 0;
-      return `${this.enum(enumVals)}${this.#suffixes(defaultValue, required, false)}`;
+      return `${this.enum(schema.type, enumVals)}${this.#suffixes(defaultValue, required, false)}`;
     }
     const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
     if (!types.length) {
@@ -352,7 +661,7 @@ function appendDefault(defaultValue) {
 
 // packages/typescript/src/lib/sdk.ts
 import { get } from "lodash-es";
-import { camelcase, pascalcase, spinalcase } from "stringcase";
+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
@@ -705,7 +1014,7 @@ function generateInputs(operationsSet, commonZod, makeImport) {
     const output = [];
     const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
     for (const operation of operations) {
-      const schemaName = camelcase(`${operation.name} schema`);
+      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 inputContent = schema;
       for (const schema2 of commonImports) {
@@ -742,8 +1051,8 @@ function generateInputs(operationsSet, commonZod, makeImport) {
   };
 }
 function toEndpoint(groupName, spec, specOperation, operation, utils) {
-  const schemaName = camelcase(`${operation.name} schema`);
-  const schemaRef = `${camelcase(groupName)}.${schemaName}`;
+  const schemaName = camelcase2(`${operation.name} schema`);
+  const schemaRef = `${camelcase2(groupName)}.${schemaName}`;
   const inputHeaders = [];
   const inputQuery = [];
   const inputBody = [];
@@ -776,12 +1085,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 = isRef4(specOperation.responses[status]) ? followRef3(spec, specOperation.responses[status].$ref) : specOperation.responses[status];
     const handled = handleResponse(
       spec,
       operation.name,
@@ -928,6 +1232,9 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
   return { schemas, imports, endpointImports, responses, outputs };
 }
 
+// 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};";
+
 // packages/typescript/src/lib/generator.ts
 function generateCode(config) {
   const commonZod = /* @__PURE__ */ new Map();
@@ -983,21 +1290,37 @@ function generateCode(config) {
     const schemas = {};
     const shortContenTypeMap = {
       "application/json": "json",
+      "application/*+json": "json",
+      // type specific of json like application/vnd.api+json (from the generation pov it shouldn't matter)
+      "text/json": "json",
+      // non standard - later standardized to application/json
       "application/x-www-form-urlencoded": "urlencoded",
       "multipart/form-data": "formdata",
       "application/xml": "xml",
       "text/plain": "text"
     };
     let outgoingContentType;
-    if (operation.requestBody && Object.keys(operation.requestBody).length) {
-      const content = isRef5(operation.requestBody) ? get2(followRef4(config.spec, operation.requestBody.$ref), ["content"]) : operation.requestBody.content;
-      for (const type in content) {
-        const ctSchema = isRef5(content[type].schema) ? followRef4(config.spec, content[type].schema.$ref) : content[type].schema;
+    if (!isEmpty(operation.requestBody)) {
+      const requestBody = isRef5(operation.requestBody) ? followRef4(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;
         if (!ctSchema) {
-          console.warn(`Schema not found for ${type}`);
+          console.warn(
+            `Schema not found for ${type} in ${entry.method} ${entry.path}`
+          );
           continue;
         }
-        const schema = merge({}, ctSchema, {
+        let objectSchema = ctSchema;
+        if (objectSchema.type !== "object") {
+          objectSchema = {
+            type: "object",
+            required: [requestBody.required ? "$body" : ""],
+            properties: {
+              $body: ctSchema
+            }
+          };
+        }
+        const schema = merge({}, objectSchema, {
           required: additionalProperties.filter((p) => p.required).map((p) => p.name),
           properties: additionalProperties.reduce(
             (acc, p) => ({
@@ -1007,14 +1330,14 @@ function generateCode(config) {
             {}
           )
         });
-        Object.assign(inputs, bodyInputs(config, ctSchema));
+        Object.assign(inputs, bodyInputs(config, objectSchema));
         schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
       }
-      if (content["application/json"]) {
+      if (requestBody.content["application/json"]) {
         outgoingContentType = "json";
-      } else if (content["application/x-www-form-urlencoded"]) {
+      } else if (requestBody.content["application/x-www-form-urlencoded"]) {
         outgoingContentType = "urlencoded";
-      } else if (content["multipart/form-data"]) {
+      } else if (requestBody.content["multipart/form-data"]) {
         outgoingContentType = "formdata";
       } else {
         outgoingContentType = "json";
@@ -1042,7 +1365,7 @@ function generateCode(config) {
       operation,
       {
         outgoingContentType,
-        name: entry.name,
+        name: operation.operationId,
         type: "http",
         trigger: entry,
         schemas,
@@ -1060,13 +1383,15 @@ function generateCode(config) {
         ...responses.map((it) => `export type ${it.name} = ${it.schema};`)
       );
     } else {
-      output.push(`export type ${pascalcase2(entry.name + " output")} = void;`);
+      output.push(
+        `export type ${pascalcase2(operation.operationId + " output")} = void;`
+      );
     }
     output.unshift(...useImports(output.join(""), ...responsesImports));
-    outputs[`${spinalcase2(entry.name)}.ts`] = output.join("\n");
+    outputs[`${spinalcase2(operation.operationId)}.ts`] = output.join("\n");
     endpoints[entry.groupName].push(endpoint);
     groups[entry.groupName].push({
-      name: entry.name,
+      name: operation.operationId,
       type: "http",
       inputs,
       outgoingContentType,
@@ -1091,8 +1416,8 @@ function generateCode(config) {
     {}
   );
   const allSchemas = Object.keys(endpoints).map((it) => ({
-    import: `import ${camelcase2(it)} from './${config.makeImport(spinalcase2(it))}';`,
-    use: `  ...${camelcase2(it)}`
+    import: `import ${camelcase3(it)} from './${config.makeImport(spinalcase2(it))}';`,
+    use: `  ...${camelcase3(it)}`
   }));
   const imports = [
     'import z from "zod";',
@@ -1105,44 +1430,27 @@ function generateCode(config) {
     commonSchemas,
     commonZod,
     outputs,
-    clientFiles: {},
     endpoints: {
-      [`${join("api", config.makeImport("schemas"))}`]: `
-${imports.join("\n")}
-${allSchemas.map((it) => it.import).join("\n")}
-
-const schemas = {
-${allSchemas.map((it) => it.use).join(",\n")}
-};
+      [join("api", "endpoints.ts")]: `
 
 
-type Output<T extends OutputType> = T extends {
-  parser: Parser;
-  type: Type<any>;
-}
-  ? InstanceType<T['type']>
-  : T extends Type<any>
-    ? InstanceType<T>
-    : never;
+import type z from 'zod';
+import type { ParseError } from '${config.makeImport("../http/parser")}';
+import type { ProblematicResponse, SuccessfulResponse } from '${config.makeImport(
+        "../http/response"
+      )}';
+import type { OutputType, Parser, Type } from '${config.makeImport(
+        "../http/send-request"
+      )}';
 
-export type Endpoints = {
-  [K in keyof typeof schemas]: {
-    input: z.infer<(typeof schemas)[K]['schema']>;
-    output: (typeof schemas)[K]['output'] extends [
-      infer Single extends OutputType,
-    ]
-      ? Output<Single>
-      : (typeof schemas)[K]['output'] extends readonly [
-            ...infer Tuple extends OutputType[],
-          ]
-        ? { [I in keyof Tuple]: Output<Tuple[I]> }[number]
-        : never;
-    error: ServerError | ParseError<(typeof schemas)[K]['schema']>;
-  };
-};
+import schemas from '${config.makeImport("./schemas")}';
 
-export default schemas;
+      ${endpoints_default}`,
+      [`${join("api", "schemas.ts")}`]: `${allSchemas.map((it) => it.import).join("\n")}
 
+export default {
+${allSchemas.map((it) => it.use).join(",\n")}
+};
 
 `.trim(),
       ...Object.fromEntries(
@@ -1158,14 +1466,14 @@ export default schemas;
           );
           return [
             [
-              join("api", config.makeImport(spinalcase2(name))),
+              join("api", `${spinalcase2(name)}.ts`),
               `${[
                 ...imps,
                 // ...imports,
                 `import z from 'zod';`,
                 `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${config.makeImport("../http/request")}';`,
                 `import { chunked, buffered } from "${config.makeImport("../http/parse-response")}";`,
-                `import * as ${camelcase2(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`
+                `import * as ${camelcase3(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`
               ].join(
                 "\n"
               )}
@@ -1226,22 +1534,22 @@ function bodyInputs(config, ctSchema) {
 }
 
 // packages/typescript/src/lib/http/interceptors.txt
-var interceptors_default = "import { type RequestConfig } from './request.ts';\n\nexport 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.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";
 
 // packages/typescript/src/lib/http/parse-response.txt
-var parse_response_default = 'import { parse } from "fast-content-type-parse";\n\nexport async function handleError(response: Response) {\n	try {\n		if (response.status >= 400 && response.status < 500) {\n			const body = (await response.json()) as Record<string, any>;\n			return {\n				status: response.status,\n				body: body,\n			};\n		}\n		return new Error(\n			`An error occurred while fetching the data. Status: ${response.status}`,\n		);\n	} catch (error) {\n		return error as any;\n	}\n}\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';
+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 parse<T extends z.ZodType<any, any, any>>(schema: T, input: unknown) {\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>> {\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';\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    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  }\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  }\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 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\nexport class APIError<Body, Status extends number = number> extends APIResponse<\n  Body,\n  Status\n> {}\n\n// 2xx Success\nexport class Ok<T> extends APIResponse<T, 200> {\n  static status = 200;\n}\nexport class Created<T> extends APIResponse<T, 201> {}\nexport class Accepted<T> extends APIResponse<T, 202> {}\nexport class NoContent extends APIResponse<null, 204> {}\n\n// 4xx Client Errors\nexport class BadRequest<T> extends APIError<T, 400> {}\nexport class Unauthorized<T = { message: string }> extends APIError<T, 401> {}\nexport class PaymentRequired<T = { message: string }> extends APIError<\n  T,\n  402\n> {}\nexport class Forbidden<T = { message: string }> extends APIError<T, 403> {}\nexport class NotFound<T = { message: string }> extends APIError<T, 404> {}\nexport class MethodNotAllowed<T = { message: string }> extends APIError<\n  T,\n  405\n> {}\nexport class NotAcceptable<T = { message: string }> extends APIError<T, 406> {}\nexport class Conflict<T = { message: string }> extends APIError<T, 409> {}\nexport class Gone<T = { message: string }> extends APIError<T, 410> {}\nexport class UnprocessableEntity<\n  T = { message: string; errors?: Record<string, string[]> },\n> extends APIError<T, 422> {}\nexport class TooManyRequests<\n  T = { message: string; retryAfter?: string },\n> extends APIError<T, 429> {}\nexport class PayloadTooLarge<T = { message: string }> extends APIError<\n  T,\n  413\n> {}\nexport class UnsupportedMediaType<T = { message: string }> extends APIError<\n  T,\n  415\n> {}\n\n// 5xx Server Errors\nexport class InternalServerError<T = { message: string }> extends APIError<\n  T,\n  500\n> {}\nexport class NotImplemented<T = { message: string }> extends APIError<T, 501> {}\nexport class BadGateway<T = { message: string }> extends APIError<T, 502> {}\nexport class ServiceUnavailable<\n  T = { message: string; retryAfter?: string },\n> extends APIError<T, 503> {}\nexport class GatewayTimeout<T = { message: string }> extends APIError<T, 504> {}\n\nexport type ClientError =\n  | BadRequest<{ message: string }>\n  | Unauthorized\n  | PaymentRequired\n  | Forbidden\n  | NotFound\n  | MethodNotAllowed\n  | NotAcceptable\n  | Conflict\n  | Gone\n  | UnprocessableEntity\n  | TooManyRequests;\n\nexport type ServerError =\n  | InternalServerError\n  | NotImplemented\n  | BadGateway\n  | ServiceUnavailable\n  | GatewayTimeout;\n\nexport type ProblematicResponse = ClientError | ServerError;\n";
+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;";
 
 // 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> };\ntype Constructor<T> = new (...args: any[]) => T;\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] = parse(route.schema, input);\n  if (parseError) {\n    return [null as never, { ...parseError, kind: 'parse' } 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\n  let output: Constructor<APIResponse> | null = APIResponse;\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  const data = new output(response.status, await parser(response));\n  if (response.ok) {\n    return [data as never, null] as const;\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 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  <% 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 data = (output || APIResponse).create(\n      response.status,\n      await parser(response),\n    );\n    <% if(throwError) { %>\n    return data;\n    <% } else { %>\n    return [data as never, 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) {
@@ -1269,11 +1577,13 @@ async function generate(spec, settings) {
   const makeImport = (moduleSpecifier) => {
     return settings.useTsExtension ? `${moduleSpecifier}.ts` : moduleSpecifier;
   };
-  const { commonSchemas, endpoints, groups, outputs, commonZod, clientFiles } = generateCode({
-    spec,
-    style: "github",
-    makeImport
-  });
+  const { commonSchemas, endpoints, groups, outputs, commonZod } = generateCode(
+    {
+      spec,
+      style: "github",
+      makeImport
+    }
+  );
   const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   const options = security(spec);
   const clientName = settings.name || "Client";
@@ -1285,16 +1595,18 @@ async function generate(spec, settings) {
     // 'README.md': readme,
   });
   await writeFiles(join2(output, "http"), {
-    "interceptors.ts": interceptors_default,
+    "interceptors.ts": `
+    import { type RequestConfig } from './${makeImport("request")}';
+    ${interceptors_default}`,
     "parse-response.ts": parse_response_default,
     "send-request.ts": `import z from 'zod';
 import type { Interceptor } from './${makeImport("interceptors")}';
 import { buffered } from './${makeImport("parse-response")}';
-import { parse } from './${makeImport("parser")}';
+import { parseInput } from './${makeImport("parser")}';
 import type { RequestConfig } from './${makeImport("request")}';
-import { APIResponse } from './${makeImport("response")}';
+import { APIError, APIResponse } from './${makeImport("response")}';
 
-${send_request_default}`,
+${template(send_request_default, {})({ throwError: settings.throwError })}`,
     "response.ts": response_default,
     "parser.ts": parser_default,
     "request.ts": request_default
@@ -1302,13 +1614,15 @@ ${send_request_default}`,
   await writeFiles(join2(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
-    }),
-    ...clientFiles,
+    "client.ts": client_default(
+      {
+        name: clientName,
+        servers: (spec.servers ?? []).map((server) => server.url) || [],
+        options,
+        makeImport
+      },
+      settings.throwError ?? false
+    ),
     ...inputFiles,
     ...endpoints,
     ...Object.fromEntries(