@sdk-it/typescript 0.14.5 → 0.16.0

package/dist/index.js

@@ -1,21 +1,9 @@
 // packages/typescript/src/lib/generate.ts
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
+import { spinalcase as spinalcase3 } from "stringcase";
 import { getFolderExports, methods, writeFiles } from "@sdk-it/core";
 
-// packages/typescript/src/lib/generator.ts
-import { get as get2, merge } from "lodash-es";
-import { camelcase as camelcase2, pascalcase, spinalcase as spinalcase2 } from "stringcase";
-import { removeDuplicates as removeDuplicates3 } from "@sdk-it/core";
-
-// packages/typescript/src/lib/utils.ts
-import { get } from "lodash-es";
-import { removeDuplicates as removeDuplicates2 } from "@sdk-it/core";
-
-// packages/typescript/src/lib/sdk.ts
-import { camelcase, spinalcase } from "stringcase";
-import { removeDuplicates, toLitObject as toLitObject2 } from "@sdk-it/core";
-
 // packages/typescript/src/lib/client.ts
 import { toLitObject } from "@sdk-it/core";
 var client_default = (spec) => {
@@ -42,8 +30,8 @@ var client_default = (spec) => {
   return `
 import { fetchType, sendRequest } from './http/${spec.makeImport("send-request")}';
 import z from 'zod';
-import type { Endpoints } from './${spec.makeImport("endpoints")}';
-import schemas from './${spec.makeImport("schemas")}';
+import type { Endpoints } from './api/${spec.makeImport("schemas")}';
+import schemas from './api/${spec.makeImport("schemas")}';
 import {
   createBaseUrlInterceptor,
   createHeadersInterceptor,
@@ -97,290 +85,278 @@ export class ${spec.name} {
 }`;
 };
 
-// packages/typescript/src/lib/sdk.ts
-var SchemaEndpoint = class {
-  #makeImport;
-  #imports = [];
-  constructor(makeImport) {
-    this.#makeImport = makeImport;
-    this.#imports = [
-      `import z from 'zod';`,
-      `import type { Endpoints } from '${this.#makeImport("./endpoints")}';`,
-      `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${this.#makeImport("./http/request")}';`,
-      `import type { ParseError } from '${this.#makeImport("./http/parser")}';`,
-      `import { chunked, buffered } from "${this.#makeImport("./http/parse-response")}";`
-    ];
+// packages/typescript/src/lib/generator.ts
+import { get as get2, 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";
+
+// packages/typescript/src/lib/emitters/zod.ts
+import { cleanRef, followRef, isRef, parseRef } from "@sdk-it/core";
+var ZodDeserialzer = class {
+  circularRefTracker = /* @__PURE__ */ new Set();
+  #spec;
+  #onRef;
+  constructor(spec, onRef) {
+    this.#spec = spec;
+    this.#onRef = onRef;
   }
-  #endpoints = [];
-  addEndpoint(endpoint, operation) {
-    this.#endpoints.push(`  "${endpoint}": ${operation},`);
+  /**
+   * Handle objects (properties, additionalProperties).
+   */
+  object(schema) {
+    const properties = schema.properties || {};
+    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
+      const isRequired = (schema.required ?? []).includes(key);
+      return `'${key}': ${this.handle(propSchema, isRequired)}`;
+    });
+    let additionalProps = "";
+    if (schema.additionalProperties) {
+      if (typeof schema.additionalProperties === "object") {
+        const addPropZod = this.handle(schema.additionalProperties, true);
+        additionalProps = `.catchall(${addPropZod})`;
+      } else if (schema.additionalProperties === true) {
+        additionalProps = `.catchall(z.unknown())`;
+      }
+    }
+    return `z.object({${propEntries.join(", ")}})${additionalProps}`;
   }
-  addImport(value) {
-    this.#imports.push(value);
+  /**
+   * Handle arrays (items could be a single schema or a tuple (array of schemas)).
+   * In JSON Schema 2020-12, `items` can be an array → tuple style.
+   */
+  array(schema, required = false) {
+    const { items } = schema;
+    if (!items) {
+      return `z.array(z.unknown())${appendOptional(required)}`;
+    }
+    if (Array.isArray(items)) {
+      const tupleItems = items.map((sub) => this.handle(sub, true));
+      const base = `z.tuple([${tupleItems.join(", ")}])`;
+      return `${base}${appendOptional(required)}`;
+    }
+    const itemsSchema = this.handle(items, true);
+    return `z.array(${itemsSchema})${appendOptional(required)}`;
   }
-  complete() {
-    return `${this.#imports.join("\n")}
-export default {
-${this.#endpoints.join("\n")}
-}`;
+  #suffixes = (defaultValue, required, nullable) => {
+    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional(required)}`;
+  };
+  /**
+   * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
+   * We'll also handle .optional() if needed.
+   */
+  normal(type, schema, required = false, nullable = false) {
+    switch (type) {
+      case "string":
+        return `${this.string(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
+      case "number":
+      case "integer": {
+        const { base, defaultValue } = this.number(schema);
+        return `${base}${this.#suffixes(defaultValue, required, nullable)}`;
+      }
+      case "boolean":
+        return `z.boolean()${this.#suffixes(schema.default, required, nullable)}`;
+      case "object":
+        return `${this.object(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
+      case "array":
+        return this.array(schema, required);
+      case "null":
+        return `z.null()${appendOptional(required)}`;
+      default:
+        return `z.unknown()${appendOptional(required)}`;
+    }
   }
-};
-var Emitter = class {
-  #makeImport;
-  imports = [];
-  constructor(makeImport) {
-    this.#makeImport = makeImport;
-    this.imports = [
-      `import type z from 'zod';`,
-      `import type { ParseError } from '${this.#makeImport("./http/parser")}';`
-    ];
+  ref($ref, required) {
+    const schemaName = cleanRef($ref).split("/").pop();
+    if (this.circularRefTracker.has(schemaName)) {
+      return schemaName;
+    }
+    this.circularRefTracker.add(schemaName);
+    this.#onRef?.(
+      schemaName,
+      this.handle(followRef(this.#spec, $ref), required)
+    );
+    this.circularRefTracker.delete(schemaName);
+    return schemaName;
   }
-  endpoints = [];
-  addEndpoint(endpoint, operation) {
-    this.endpoints.push(`  "${endpoint}": ${operation};`);
+  allOf(schemas, required) {
+    const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (allOfSchemas.length === 0) {
+      return `z.unknown()`;
+    }
+    if (allOfSchemas.length === 1) {
+      return `${allOfSchemas[0]}${appendOptional(required)}`;
+    }
+    return `${this.#toIntersection(allOfSchemas)}${appendOptional(required)}`;
   }
-  addImport(value) {
-    this.imports.push(value);
+  #toIntersection(schemas) {
+    const [left, ...right] = schemas;
+    if (!right.length) {
+      return left;
+    }
+    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
   }
-  complete() {
-    return `${this.imports.join("\n")}
-export interface Endpoints {
-${this.endpoints.join("\n")}
-}`;
+  anyOf(schemas, required) {
+    const anyOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (anyOfSchemas.length === 1) {
+      return `${anyOfSchemas[0]}${appendOptional(required)}`;
+    }
+    return `z.union([${anyOfSchemas.join(", ")}])${appendOptional(required)}`;
   }
-};
-function generateInputs(operationsSet, commonZod, makeImport) {
-  const commonImports = commonZod.keys().toArray();
-  const inputs = {};
-  for (const [name, operations] of Object.entries(operationsSet)) {
-    const output = [];
-    const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
-    for (const operation of operations) {
-      const schemaName = camelcase(`${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) {
-        if (inputContent.includes(schema2)) {
-          imports.add(
-            `import { ${schema2} } from './schemas/${makeImport(spinalcase(schema2))}';`
-          );
+  oneOf(schemas, required) {
+    const oneOfSchemas = schemas.map((sub) => {
+      if (isRef(sub)) {
+        const { model } = parseRef(sub.$ref);
+        if (this.circularRefTracker.has(model)) {
+          return `${model}${appendOptional(required)}`;
         }
       }
-      output.push(inputContent);
+      return this.handle(sub, true);
+    });
+    if (oneOfSchemas.length === 1) {
+      return `${oneOfSchemas[0]}${appendOptional(required)}`;
     }
-    inputs[`inputs/${spinalcase(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
+    return `z.union([${oneOfSchemas.join(", ")}])${appendOptional(required)}`;
   }
-  const schemas = commonZod.entries().reduce((acc, [name, schema]) => {
-    const output = [`import { z } from 'zod';`];
-    const content = `export const ${name} = ${schema};`;
-    for (const schema2 of commonImports) {
-      const preciseMatch = new RegExp(`\\b${schema2}\\b`);
-      if (preciseMatch.test(content) && schema2 !== name) {
-        output.push(
-          `import { ${schema2} } from './${makeImport(spinalcase(schema2))}';`
-        );
-      }
-    }
-    output.push(content);
-    return [
-      [`inputs/schemas/${spinalcase(name)}.ts`, output.join("\n")],
-      ...acc
-    ];
-  }, []);
-  return {
-    ...Object.fromEntries(schemas),
-    ...inputs
-  };
-}
-function generateSDK(spec) {
-  const emitter = new Emitter(spec.makeImport);
-  const schemaEndpoint = new SchemaEndpoint(spec.makeImport);
-  const errors = [];
-  for (const [name, operations] of Object.entries(spec.operations)) {
-    emitter.addImport(
-      `import type * as ${camelcase(name)} from './inputs/${spec.makeImport(spinalcase(name))}';`
-    );
-    schemaEndpoint.addImport(
-      `import * as ${camelcase(name)} from './inputs/${spec.makeImport(spinalcase(name))}';`
-    );
-    for (const operation of operations) {
-      const schemaName = camelcase(`${operation.name} schema`);
-      const schemaRef = `${camelcase(name)}.${schemaName}`;
-      const output = operation.formatOutput();
-      const inputHeaders = [];
-      const inputQuery = [];
-      const inputBody = [];
-      const inputParams = [];
-      for (const [name2, prop] of Object.entries(operation.inputs)) {
-        if (prop.in === "headers" || prop.in === "header") {
-          inputHeaders.push(`"${name2}"`);
-        } else if (prop.in === "query") {
-          inputQuery.push(`"${name2}"`);
-        } else if (prop.in === "body") {
-          inputBody.push(`"${name2}"`);
-        } else if (prop.in === "path") {
-          inputParams.push(`"${name2}"`);
-        } else if (prop.in === "internal") {
-          continue;
-        } else {
-          throw new Error(
-            `Unknown source ${prop.in} in ${name2} ${JSON.stringify(
-              prop
-            )} in ${operation.name}`
-          );
-        }
-      }
-      emitter.addImport(
-        `import type {${output.import}} from './outputs/${spec.makeImport(spinalcase(operation.name))}';`
-      );
-      errors.push(...operation.errors ?? []);
-      const addTypeParser = Object.keys(operation.schemas).length > 1;
-      for (const type in operation.schemas ?? {}) {
-        let typePrefix = "";
-        if (addTypeParser && type !== "json") {
-          typePrefix = `${type} `;
-        }
-        const input = `typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}`;
-        const endpoint = `${typePrefix}${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
-        emitter.addEndpoint(
-          endpoint,
-          `{input: z.infer<${input}>; output: ${output.use}; error: ${(operation.errors ?? ["ServerError"]).concat(`ParseError<${input}>`).join("|")}}`
-        );
-        schemaEndpoint.addEndpoint(
-          endpoint,
-          `{
-          schema: ${schemaRef}${addTypeParser ? `.${type}` : ""},
-          deserializer: ${operation.parser === "chunked" ? "chunked" : "buffered"},
-          toRequest(input: Endpoints['${endpoint}']['input']) {
-            const endpoint = '${endpoint}';
-                return toRequest(endpoint, ${operation.outgoingContentType || "nobody"}(input, {
-                inputHeaders: [${inputHeaders}],
-                inputQuery: [${inputQuery}],
-                inputBody: [${inputBody}],
-                inputParams: [${inputParams}],
-              }));
-            },
-          }`
-        );
-      }
+  enum(values) {
+    if (values.length === 1) {
+      return `z.literal(${values.join(", ")})`;
     }
+    return `z.enum([${values.join(", ")}])`;
   }
-  emitter.addImport(
-    `import type { ${removeDuplicates(errors, (it) => it).join(", ")} } from '${spec.makeImport("./http/response")}';`
-  );
-  return {
-    "client.ts": client_default(spec),
-    "schemas.ts": schemaEndpoint.complete(),
-    "endpoints.ts": emitter.complete()
-  };
-}
-
-// packages/typescript/src/lib/utils.ts
-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);
-  return { model, path: 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);
+  /**
+   * Handle a `string` schema with possible format keywords (JSON Schema).
+   */
+  string(schema) {
+    let base = "z.string()";
+    switch (schema.format) {
+      case "date-time":
+      case "datetime":
+        base = "z.coerce.date()";
+        break;
+      case "date":
+        base = "z.coerce.date() /* or z.string() if you want raw date strings */";
+        break;
+      case "time":
+        base = "z.string() /* optionally add .regex(...) for HH:MM:SS format */";
+        break;
+      case "email":
+        base = "z.string().email()";
+        break;
+      case "uuid":
+        base = "z.string().uuid()";
+        break;
+      case "url":
+      case "uri":
+        base = "z.string().url()";
+        break;
+      case "ipv4":
+        base = 'z.string().ip({version: "v4"})';
+        break;
+      case "ipv6":
+        base = 'z.string().ip({version: "v6"})';
+        break;
+      case "phone":
+        base = "z.string() /* or add .regex(...) for phone formats */";
+        break;
+      case "byte":
+      case "binary":
+        base = "z.instanceof(Blob) /* consider base64 check if needed */";
+        break;
+      case "int64":
+        base = "z.string() /* or z.bigint() if your app can handle it */";
+        break;
+      default:
+        break;
+    }
+    return base;
   }
-  return entry;
-}
-function securityToOptions(security2, securitySchemes, staticIn) {
-  securitySchemes ??= {};
-  const options = {};
-  for (const it of security2) {
-    const [name] = Object.keys(it);
-    if (!name) {
-      continue;
+  /**
+   * Handle number/integer constraints from OpenAPI/JSON Schema.
+   * In 3.1, exclusiveMinimum/Maximum hold the actual numeric threshold,
+   * rather than a boolean toggling `minimum`/`maximum`.
+   */
+  number(schema) {
+    let defaultValue = schema.default;
+    let base = "z.number()";
+    if (schema.format === "int64") {
+      base = "z.bigint()";
+      if (schema.default !== void 0) {
+        defaultValue = `BigInt(${schema.default})`;
+      }
     }
-    const schema = securitySchemes[name];
-    if (isRef(schema)) {
-      throw new Error(`Ref security schemas are not supported`);
+    if (schema.format === "int32") {
+      base += ".int()";
     }
-    if (schema.type === "http") {
-      options["authorization"] = {
-        in: staticIn ?? "header",
-        schema: "z.string().optional().transform((val) => (val ? `Bearer ${val}` : undefined))",
-        optionName: "token"
-      };
-      continue;
+    if (typeof schema.exclusiveMinimum === "number") {
+      base += `.gt(${schema.exclusiveMinimum})`;
     }
-    if (schema.type === "apiKey") {
-      if (!schema.in) {
-        throw new Error(`apiKey security schema must have an "in" field`);
-      }
-      if (!schema.name) {
-        throw new Error(`apiKey security schema must have a "name" field`);
-      }
-      options[schema.name] = {
-        in: staticIn ?? schema.in,
-        schema: "z.string().optional()"
-      };
-      continue;
+    if (typeof schema.exclusiveMaximum === "number") {
+      base += `.lt(${schema.exclusiveMaximum})`;
+    }
+    if (typeof schema.minimum === "number") {
+      base += schema.format === "int64" ? `.min(BigInt(${schema.minimum}))` : `.min(${schema.minimum})`;
+    }
+    if (typeof schema.maximum === "number") {
+      base += schema.format === "int64" ? `.max(BigInt(${schema.maximum}))` : `.max(${schema.maximum})`;
+    }
+    if (typeof schema.multipleOf === "number") {
+      base += `.refine((val) => Number.isInteger(val / ${schema.multipleOf}), "Must be a multiple of ${schema.multipleOf}")`;
     }
+    return { base, defaultValue };
   }
-  return options;
-}
-function mergeImports(imports) {
-  const merged = {};
-  for (const i of imports) {
-    merged[i.moduleSpecifier] = merged[i.moduleSpecifier] ?? {
-      moduleSpecifier: i.moduleSpecifier,
-      defaultImport: i.defaultImport,
-      namespaceImport: i.namespaceImport,
-      namedImports: []
-    };
-    if (i.namedImports) {
-      merged[i.moduleSpecifier].namedImports.push(...i.namedImports);
+  handle(schema, required) {
+    if (isRef(schema)) {
+      return `${this.ref(schema.$ref, true)}${appendOptional(required)}`;
     }
-  }
-  return Object.values(merged);
-}
-function importsToString(...imports) {
-  return imports.map((it) => {
-    if (it.defaultImport) {
-      return `import ${it.defaultImport} from '${it.moduleSpecifier}'`;
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      return this.allOf(schema.allOf ?? [], required);
     }
-    if (it.namespaceImport) {
-      return `import * as ${it.namespaceImport} from '${it.moduleSpecifier}'`;
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      return this.anyOf(schema.anyOf ?? [], required);
     }
-    if (it.namedImports) {
-      return `import {${removeDuplicates2(it.namedImports, (it2) => it2.name).map((n) => `${n.isTypeOnly ? "type" : ""} ${n.name}`).join(", ")}} from '${it.moduleSpecifier}'`;
+    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length) {
+      return this.oneOf(schema.oneOf ?? [], required);
     }
-    throw new Error(`Invalid import ${JSON.stringify(it)}`);
-  });
-}
-function exclude(list, exclude2) {
-  return list.filter((it) => !exclude2.includes(it));
-}
-function useImports(content, imports) {
-  const output = [];
-  for (const it of mergeImports(imports)) {
-    const singleImport = it.defaultImport ?? it.namespaceImport;
-    if (singleImport && content.includes(singleImport)) {
-      output.push(importsToString(it).join("\n"));
-    } else if (it.namedImports.length) {
-      for (const namedImport of it.namedImports) {
-        if (content.includes(namedImport.name)) {
-          output.push(importsToString(it).join("\n"));
-        }
+    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)}`;
+    }
+    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    if (!types.length) {
+      return `z.unknown()${appendOptional(required)}`;
+    }
+    if ("nullable" in schema && schema.nullable) {
+      types.push("null");
+    } else if (schema.default === null) {
+      types.push("null");
+    }
+    if (types.length > 1) {
+      const realTypes = types.filter((t) => t !== "null");
+      if (realTypes.length === 1 && types.includes("null")) {
+        return this.normal(realTypes[0], schema, required, true);
       }
+      const subSchemas = types.map((t) => this.normal(t, schema, false));
+      return `z.union([${subSchemas.join(", ")}])${appendOptional(required)}`;
     }
+    return this.normal(types[0], schema, required, false);
   }
-  return output;
+};
+function appendOptional(isRequired) {
+  return isRequired ? "" : ".optional()";
+}
+function appendDefault(defaultValue) {
+  return defaultValue !== void 0 || typeof defaultValue !== "undefined" ? `.default(${defaultValue})` : "";
 }
 
+// packages/typescript/src/lib/sdk.ts
+import { get } from "lodash-es";
+import { camelcase, 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;
@@ -499,7 +475,7 @@ var TypeScriptDeserialzer = class {
       case "integer":
         return this.number(schema, required);
       case "boolean":
-        return appendOptional("boolean", required);
+        return appendOptional2("boolean", required);
       case "object":
         return this.object(schema, required);
       case "array":
@@ -507,18 +483,22 @@ var TypeScriptDeserialzer = class {
       case "null":
         return "null";
       default:
-        return appendOptional("any", required);
+        console.warn(`Unknown type: ${type}`);
+        return appendOptional2("any", required);
     }
   }
   ref($ref, required) {
-    const schemaName = cleanRef($ref).split("/").pop();
+    const schemaName = cleanRef2($ref).split("/").pop();
     if (this.circularRefTracker.has(schemaName)) {
       return schemaName;
     }
     this.circularRefTracker.add(schemaName);
-    this.#onRef(schemaName, this.handle(followRef(this.#spec, $ref), true));
+    this.#onRef?.(
+      schemaName,
+      this.handle(followRef2(this.#spec, $ref), required)
+    );
     this.circularRefTracker.delete(schemaName);
-    return appendOptional(schemaName, required);
+    return appendOptional2(schemaName, required);
   }
   allOf(schemas) {
     const allOfTypes = schemas.map((sub) => this.handle(sub, true));
@@ -526,29 +506,29 @@ var TypeScriptDeserialzer = class {
   }
   anyOf(schemas, required) {
     const anyOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return appendOptional(
+    return appendOptional2(
       anyOfTypes.length > 1 ? `${anyOfTypes.join(" | ")}` : anyOfTypes[0],
       required
     );
   }
   oneOf(schemas, required) {
     const oneOfTypes = schemas.map((sub) => {
-      if (isRef(sub)) {
-        const { model } = parseRef(sub.$ref);
+      if (isRef2(sub)) {
+        const { model } = parseRef2(sub.$ref);
         if (this.circularRefTracker.has(model)) {
           return model;
         }
       }
       return this.handle(sub, false);
     });
-    return appendOptional(
+    return appendOptional2(
       oneOfTypes.length > 1 ? `${oneOfTypes.join(" | ")}` : oneOfTypes[0],
       required
     );
   }
   enum(values, required) {
     const enumValues = values.map((val) => typeof val === "string" ? `'${val}'` : `${val}`).join(" | ");
-    return appendOptional(enumValues, required);
+    return appendOptional2(enumValues, required);
   }
   /**
    * Handle string type with formats
@@ -571,17 +551,17 @@ var TypeScriptDeserialzer = class {
       default:
         type = "string";
     }
-    return appendOptional(type, required);
+    return appendOptional2(type, required);
   }
   /**
    * Handle number/integer types with formats
    */
   number(schema, required) {
     const type = schema.format === "int64" ? "bigint" : "number";
-    return appendOptional(type, required);
+    return appendOptional2(type, required);
   }
   handle(schema, required) {
-    if (isRef(schema)) {
+    if (isRef2(schema)) {
       return this.ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -601,16 +581,16 @@ var TypeScriptDeserialzer = class {
       if ("properties" in schema) {
         return this.object(schema, required);
       }
-      return appendOptional("any", required);
+      return appendOptional2("any", required);
     }
     if (types.length > 1) {
       const realTypes = types.filter((t) => t !== "null");
       if (realTypes.length === 1 && types.includes("null")) {
         const tsType = this.normal(realTypes[0], schema, false);
-        return appendOptional(`${tsType} | null`, required);
+        return appendOptional2(`${tsType} | null`, required);
       }
       const typeResults = types.map((t) => this.normal(t, schema, false));
-      return appendOptional(typeResults.join(" | "), required);
+      return appendOptional2(typeResults.join(" | "), required);
     }
     return this.normal(types[0], schema, required);
   }
@@ -622,275 +602,228 @@ var TypeScriptDeserialzer = class {
     return `interface ${name} ${content}`;
   }
 };
-function appendOptional(type, isRequired) {
+function appendOptional2(type, isRequired) {
   return isRequired ? type : `${type} | undefined`;
 }
-
-// packages/typescript/src/lib/emitters/zod.ts
-var ZodDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
-  #spec;
-  #onRef;
-  constructor(spec, onRef) {
-    this.#spec = spec;
-    this.#onRef = onRef;
-  }
-  /**
-   * Handle objects (properties, additionalProperties).
-   */
-  object(schema, required = false) {
-    const properties = schema.properties || {};
-    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
-      const isRequired = (schema.required ?? []).includes(key);
-      const zodPart = this.handle(propSchema, isRequired);
-      return `'${key}': ${zodPart}`;
-    });
-    let additionalProps = "";
-    if (schema.additionalProperties) {
-      if (typeof schema.additionalProperties === "object") {
-        const addPropZod = this.handle(schema.additionalProperties, true);
-        additionalProps = `.catchall(${addPropZod})`;
-      } else if (schema.additionalProperties === true) {
-        additionalProps = `.catchall(z.unknown())`;
-      }
-    }
-    const objectSchema = `z.object({${propEntries.join(", ")}})${additionalProps}`;
-    return `${objectSchema}${appendOptional2(required)}`;
-  }
-  /**
-   * Handle arrays (items could be a single schema or a tuple (array of schemas)).
-   * In JSON Schema 2020-12, `items` can be an array → tuple style.
-   */
-  array(schema, required = false) {
-    const { items } = schema;
-    if (!items) {
-      return `z.array(z.unknown())${appendOptional2(required)}`;
-    }
-    if (Array.isArray(items)) {
-      const tupleItems = items.map((sub) => this.handle(sub, true));
-      const base = `z.tuple([${tupleItems.join(", ")}])`;
-      return `${base}${appendOptional2(required)}`;
-    }
-    const itemsSchema = this.handle(items, true);
-    return `z.array(${itemsSchema})${appendOptional2(required)}`;
-  }
-  #suffixes = (defaultValue, required, nullable) => {
-    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional2(required)}`;
-  };
-  /**
-   * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
-   * We'll also handle .optional() if needed.
-   */
-  normal(type, schema, required = false, nullable = false) {
-    switch (type) {
-      case "string":
-        return `${this.string(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
-      case "number":
-      case "integer": {
-        const { base, defaultValue } = this.number(schema);
-        return `${base}${this.#suffixes(defaultValue, required, nullable)}`;
-      }
-      case "boolean":
-        return `z.boolean()${this.#suffixes(schema.default, required, nullable)}`;
-      case "object":
-        return this.object(schema, true);
-      case "array":
-        return this.array(schema, required);
-      case "null":
-        return `z.null()${appendOptional2(required)}`;
-      default:
-        return `z.unknown()${appendOptional2(required)}`;
-    }
-  }
-  ref($ref, required) {
-    const schemaName = cleanRef($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
-      return schemaName;
-    }
-    this.circularRefTracker.add(schemaName);
-    this.#onRef?.(
-      schemaName,
-      this.handle(followRef(this.#spec, $ref), required)
-    );
-    this.circularRefTracker.delete(schemaName);
-    return schemaName;
-  }
-  allOf(schemas) {
-    const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
-    if (allOfSchemas.length === 0) {
-      return `z.unknown()`;
-    }
-    if (allOfSchemas.length === 1) {
-      return allOfSchemas[0];
-    }
-    return this.#toIntersection(allOfSchemas);
-  }
-  #toIntersection(schemas) {
-    const [left, ...right] = schemas;
-    if (!right.length) {
-      return left;
-    }
-    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
-  }
-  anyOf(schemas, required) {
-    const anyOfSchemas = schemas.map((sub) => this.handle(sub, false));
-    if (anyOfSchemas.length === 1) {
-      return anyOfSchemas[0];
-    }
-    return anyOfSchemas.length > 1 ? `z.union([${anyOfSchemas.join(", ")}])${appendOptional2(required)}` : (
-      // Handle an invalid anyOf with one schema
-      anyOfSchemas[0]
-    );
-  }
-  oneOf(schemas, required) {
-    const oneOfSchemas = schemas.map((sub) => {
-      if (isRef(sub)) {
-        const { model } = parseRef(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return model;
-        }
-      }
-      return this.handle(sub, true);
-    });
-    if (oneOfSchemas.length === 1) {
-      return oneOfSchemas[0];
-    }
-    return oneOfSchemas.length > 1 ? `z.union([${oneOfSchemas.join(", ")}])${appendOptional2(required)}` : (
-      // Handle an invalid oneOf with one schema
-      oneOfSchemas[0]
-    );
-  }
-  enum(values, required) {
-    const enumVals = values.map((val) => JSON.stringify(val)).join(", ");
-    if (values.length === 1) {
-      return `z.literal(${enumVals})${appendOptional2(required)}`;
-    }
-    return `z.enum([${enumVals}])${appendOptional2(required)}`;
-  }
-  /**
-   * Handle a `string` schema with possible format keywords (JSON Schema).
-   */
-  string(schema) {
-    let base = "z.string()";
-    switch (schema.format) {
-      case "date-time":
-      case "datetime":
-        base = "z.coerce.date()";
-        break;
-      case "date":
-        base = "z.coerce.date() /* or z.string() if you want raw date strings */";
-        break;
-      case "time":
-        base = "z.string() /* optionally add .regex(...) for HH:MM:SS format */";
-        break;
-      case "email":
-        base = "z.string().email()";
-        break;
-      case "uuid":
-        base = "z.string().uuid()";
-        break;
-      case "url":
-      case "uri":
-        base = "z.string().url()";
-        break;
-      case "ipv4":
-        base = 'z.string().ip({version: "v4"})';
-        break;
-      case "ipv6":
-        base = 'z.string().ip({version: "v6"})';
-        break;
-      case "phone":
-        base = "z.string() /* or add .regex(...) for phone formats */";
-        break;
-      case "byte":
-      case "binary":
-        base = "z.instanceof(Blob) /* consider base64 check if needed */";
-        break;
-      case "int64":
-        base = "z.string() /* or z.bigint() if your app can handle it */";
-        break;
-      default:
-        break;
-    }
-    return base;
-  }
-  /**
-   * Handle number/integer constraints from OpenAPI/JSON Schema.
-   * In 3.1, exclusiveMinimum/Maximum hold the actual numeric threshold,
-   * rather than a boolean toggling `minimum`/`maximum`.
-   */
-  number(schema) {
-    let defaultValue = schema.default;
-    let base = "z.number()";
-    if (schema.format === "int64") {
-      base = "z.bigint()";
-      if (schema.default !== void 0) {
-        defaultValue = `BigInt(${schema.default})`;
-      }
-    }
-    if (schema.format === "int32") {
-      base += ".int()";
-    }
-    if (typeof schema.exclusiveMinimum === "number") {
-      base += `.gt(${schema.exclusiveMinimum})`;
-    }
-    if (typeof schema.exclusiveMaximum === "number") {
-      base += `.lt(${schema.exclusiveMaximum})`;
+
+// packages/typescript/src/lib/utils.ts
+import { isRef as isRef3, removeDuplicates } from "@sdk-it/core";
+function securityToOptions(security2, securitySchemes, staticIn) {
+  securitySchemes ??= {};
+  const options = {};
+  for (const it of security2) {
+    const [name] = Object.keys(it);
+    if (!name) {
+      continue;
     }
-    if (typeof schema.minimum === "number") {
-      base += schema.format === "int64" ? `.min(BigInt(${schema.minimum}))` : `.min(${schema.minimum})`;
+    const schema = securitySchemes[name];
+    if (isRef3(schema)) {
+      throw new Error(`Ref security schemas are not supported`);
     }
-    if (typeof schema.maximum === "number") {
-      base += schema.format === "int64" ? `.max(BigInt(${schema.maximum}))` : `.max(${schema.maximum})`;
+    if (schema.type === "http") {
+      options["authorization"] = {
+        in: staticIn ?? "header",
+        schema: "z.string().optional().transform((val) => (val ? `Bearer ${val}` : undefined))",
+        optionName: "token"
+      };
+      continue;
     }
-    if (typeof schema.multipleOf === "number") {
-      base += `.refine((val) => Number.isInteger(val / ${schema.multipleOf}), "Must be a multiple of ${schema.multipleOf}")`;
+    if (schema.type === "apiKey") {
+      if (!schema.in) {
+        throw new Error(`apiKey security schema must have an "in" field`);
+      }
+      if (!schema.name) {
+        throw new Error(`apiKey security schema must have a "name" field`);
+      }
+      options[schema.name] = {
+        in: staticIn ?? schema.in,
+        schema: "z.string().optional()"
+      };
+      continue;
     }
-    return { base, defaultValue };
   }
-  handle(schema, required) {
-    if (isRef(schema)) {
-      return this.ref(schema.$ref, required);
-    }
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-      return this.allOf(schema.allOf ?? []);
-    }
-    if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.anyOf(schema.anyOf ?? [], required);
+  return options;
+}
+function mergeImports(...imports) {
+  const merged = {};
+  for (const it of imports) {
+    merged[it.moduleSpecifier] = merged[it.moduleSpecifier] ?? {
+      moduleSpecifier: it.moduleSpecifier,
+      defaultImport: it.defaultImport,
+      namespaceImport: it.namespaceImport,
+      namedImports: []
+    };
+    for (const named of it.namedImports) {
+      if (!merged[it.moduleSpecifier].namedImports.some(
+        (x) => x.name === named.name
+      )) {
+        merged[it.moduleSpecifier].namedImports.push(named);
+      }
     }
-    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length) {
-      return this.oneOf(schema.oneOf ?? [], required);
+  }
+  return Object.values(merged);
+}
+function importsToString(...imports) {
+  return imports.map((it) => {
+    if (it.defaultImport) {
+      return `import ${it.defaultImport} from '${it.moduleSpecifier}'`;
     }
-    if (schema.enum && Array.isArray(schema.enum)) {
-      return this.enum(schema.enum, required);
+    if (it.namespaceImport) {
+      return `import * as ${it.namespaceImport} from '${it.moduleSpecifier}'`;
     }
-    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-    if (!types.length) {
-      return `z.unknown()${appendOptional2(required)}`;
+    if (it.namedImports) {
+      return `import {${removeDuplicates(it.namedImports, (it2) => it2.name).map((n) => `${n.isTypeOnly ? "type" : ""} ${n.name}`).join(", ")}} from '${it.moduleSpecifier}'`;
     }
-    if ("nullable" in schema && schema.nullable) {
-      types.push("null");
+    throw new Error(`Invalid import ${JSON.stringify(it)}`);
+  });
+}
+function exclude(list, exclude2) {
+  return list.filter((it) => !exclude2.includes(it));
+}
+function useImports(content, ...imports) {
+  const output = [];
+  for (const it of mergeImports(...imports)) {
+    const singleImport = it.defaultImport ?? it.namespaceImport;
+    if (singleImport && content.includes(singleImport)) {
+      output.push(importsToString(it).join("\n"));
+    } else if (it.namedImports.length) {
+      for (const namedImport of it.namedImports) {
+        if (content.includes(namedImport.name)) {
+          output.push(importsToString(it).join("\n"));
+        }
+      }
     }
-    if (types.length > 1) {
-      const realTypes = types.filter((t) => t !== "null");
-      if (realTypes.length === 1 && types.includes("null")) {
-        return this.normal(realTypes[0], schema, required, true);
+  }
+  return output;
+}
+
+// packages/typescript/src/lib/sdk.ts
+function generateInputs(operationsSet, commonZod, makeImport) {
+  const commonImports = commonZod.keys().toArray();
+  const inputs = {};
+  for (const [name, operations] of Object.entries(operationsSet)) {
+    const output = [];
+    const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
+    for (const operation of operations) {
+      const schemaName = camelcase(`${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) {
+        if (inputContent.includes(schema2)) {
+          imports.add(
+            `import { ${schema2} } from './schemas/${makeImport(spinalcase(schema2))}';`
+          );
+        }
       }
-      const subSchemas = types.map((t) => this.normal(t, schema, false));
-      return `z.union([${subSchemas.join(", ")}])${appendOptional2(required)}`;
+      output.push(inputContent);
     }
-    return this.normal(types[0], schema, required, false);
+    inputs[`inputs/${spinalcase(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
   }
-};
-function appendOptional2(isRequired) {
-  return isRequired ? "" : ".optional()";
+  const schemas = commonZod.entries().reduce((acc, [name, schema]) => {
+    const output = [`import { z } from 'zod';`];
+    const content = `export const ${name} = ${schema};`;
+    for (const schema2 of commonImports) {
+      const preciseMatch = new RegExp(`\\b${schema2}\\b`);
+      if (preciseMatch.test(content) && schema2 !== name) {
+        output.push(
+          `import { ${schema2} } from './${makeImport(spinalcase(schema2))}';`
+        );
+      }
+    }
+    output.push(content);
+    return [
+      [`inputs/schemas/${spinalcase(name)}.ts`, output.join("\n")],
+      ...acc
+    ];
+  }, []);
+  return {
+    ...Object.fromEntries(schemas),
+    ...inputs
+  };
 }
-function appendDefault(defaultValue) {
-  return defaultValue !== void 0 ? `.default(${defaultValue})` : "";
+function toEndpoint(groupName, spec, specOperation, operation, utils) {
+  const schemaName = camelcase(`${operation.name} schema`);
+  const schemaRef = `${camelcase(groupName)}.${schemaName}`;
+  const inputHeaders = [];
+  const inputQuery = [];
+  const inputBody = [];
+  const inputParams = [];
+  const schemas = [];
+  const responses = [];
+  for (const [name, prop] of Object.entries(operation.inputs)) {
+    if (prop.in === "headers" || prop.in === "header") {
+      inputHeaders.push(`"${name}"`);
+    } else if (prop.in === "query") {
+      inputQuery.push(`"${name}"`);
+    } else if (prop.in === "body") {
+      inputBody.push(`"${name}"`);
+    } else if (prop.in === "path") {
+      inputParams.push(`"${name}"`);
+    } else if (prop.in === "internal") {
+      continue;
+    } else {
+      throw new Error(
+        `Unknown source ${prop.in} in ${name} ${JSON.stringify(
+          prop
+        )} in ${operation.name}`
+      );
+    }
+  }
+  specOperation.responses ??= {};
+  const outputs = [];
+  const statusesCount = Object.keys(specOperation.responses).filter((status) => {
+    const statusCode = +status;
+    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 handled = handleResponse(
+      spec,
+      operation.name,
+      status,
+      response,
+      utils,
+      true
+      // statusesCount,
+    );
+    responses.push(handled);
+    outputs.push(...handled.outputs);
+  }
+  const addTypeParser = Object.keys(operation.schemas).length > 1;
+  for (const type in operation.schemas ?? {}) {
+    let typePrefix = "";
+    if (addTypeParser && type !== "json") {
+      typePrefix = `${type} `;
+    }
+    const endpoint = `${typePrefix}${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
+    schemas.push(
+      `"${endpoint}": {
+          schema: ${schemaRef}${addTypeParser ? `.${type}` : ""},
+          output:[${outputs.join(",")}],
+          toRequest(input: z.infer<typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}>) {
+            const endpoint = '${endpoint}';
+                return toRequest(endpoint, ${operation.outgoingContentType || "nobody"}(input, {
+                inputHeaders: [${inputHeaders}],
+                inputQuery: [${inputQuery}],
+                inputBody: [${inputBody}],
+                inputParams: [${inputParams}],
+              }));
+            },
+          }`
+    );
+  }
+  return { responses, schemas };
 }
-
-// packages/typescript/src/lib/generator.ts
-var statusCdeToMessageMap = {
+var statusCodeToResponseMap = {
+  "200": "Ok",
+  "201": "Created",
+  "202": "Accepted",
+  "204": "NoContent",
   "400": "BadRequest",
   "401": "Unauthorized",
   "402": "PaymentRequired",
@@ -909,18 +842,94 @@ var statusCdeToMessageMap = {
   "503": "ServiceUnavailable",
   "504": "GatewayTimeout"
 };
-var defaults = {
-  target: "javascript",
-  style: "github",
-  operationId: (operation, path, method) => {
-    if (operation.operationId) {
-      return spinalcase2(operation.operationId);
-    }
-    return camelcase2(`${method} ${path.replace(/[\\/\\{\\}]/g, " ").trim()}`);
+function handleResponse(spec, operationName, status, response, utils, numbered) {
+  const schemas = {};
+  const imports = {};
+  const endpointImports = {
+    ParseError: {
+      defaultImport: void 0,
+      isTypeOnly: false,
+      moduleSpecifier: utils.makeImport(`../http/parser`),
+      namedImports: [{ isTypeOnly: false, name: "ParseError" }],
+      namespaceImport: void 0
+    }
+  };
+  const responses = [];
+  const outputs = [];
+  const typeScriptDeserialzer = new TypeScriptDeserialzer(
+    spec,
+    (schemaName, zod) => {
+      schemas[schemaName] = zod;
+      imports[schemaName] = {
+        defaultImport: void 0,
+        isTypeOnly: true,
+        moduleSpecifier: `../models/${utils.makeImport(schemaName)}`,
+        namedImports: [{ isTypeOnly: true, name: schemaName }],
+        namespaceImport: void 0
+      };
+    }
+  );
+  const statusCode = +status;
+  const parser = (response.headers ?? {})["Transfer-Encoding"] ? "chunked" : "buffered";
+  const statusName = statusCodeToResponseMap[status] || "APIResponse";
+  const interfaceName = pascalcase(
+    operationName + ` output${numbered ? status : ""}`
+  );
+  if (statusCode === 204) {
+    outputs.push(statusName);
+  } else {
+    if (status.endsWith("XX")) {
+      outputs.push(`APIError<${interfaceName}>`);
+    } else {
+      outputs.push(
+        parser !== "buffered" ? `{type: ${statusName}<${interfaceName}>, parser: ${parser}}` : `${statusName}<${interfaceName}>`
+      );
+    }
   }
-};
+  const responseContent = get(response, ["content"]);
+  const isJson = responseContent && responseContent["application/json"];
+  const responseSchema = isJson ? typeScriptDeserialzer.handle(
+    responseContent["application/json"].schema,
+    true
+  ) : "void";
+  responses.push({
+    name: interfaceName,
+    schema: responseSchema
+  });
+  const statusGroup = +status.slice(0, 1);
+  if (statusCode >= 400 || statusGroup >= 4) {
+    endpointImports[statusCodeToResponseMap[status] ?? "APIError"] = {
+      moduleSpecifier: utils.makeImport("../http/response"),
+      namedImports: [{ name: statusCodeToResponseMap[status] ?? "APIError" }]
+    };
+    endpointImports[interfaceName] = {
+      isTypeOnly: true,
+      moduleSpecifier: `../outputs/${utils.makeImport(spinalcase(operationName))}`,
+      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,
+      moduleSpecifier: `../outputs/${utils.makeImport(spinalcase(operationName))}`,
+      namedImports: [{ isTypeOnly: true, name: interfaceName }],
+      namespaceImport: void 0
+    };
+  }
+  return { schemas, imports, endpointImports, responses, outputs };
+}
+
+// packages/typescript/src/lib/generator.ts
 function generateCode(config) {
-  const commonSchemas = {};
   const commonZod = /* @__PURE__ */ new Map();
   const commonZodImports = [];
   const zodDeserialzer = new ZodDeserialzer(config.spec, (model, schema) => {
@@ -935,191 +944,244 @@ function generateCode(config) {
   });
   const groups = {};
   const outputs = {};
-  for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
-    const { parameters = [], ...methods2 } = pathItem;
-    for (const [method, operation] of Object.entries(methods2)) {
-      const formatOperationId = config.operationId ?? defaults.operationId;
-      const operationName = formatOperationId(operation, path, method);
-      console.log(`Processing ${method} ${path}`);
-      const [groupName] = Array.isArray(operation.tags) ? operation.tags : ["unknown"];
-      groups[groupName] ??= [];
-      const inputs = {};
-      const additionalProperties = [];
-      for (const param of [...parameters, ...operation.parameters ?? []]) {
-        if (isRef(param)) {
-          throw new Error(`Found reference in parameter ${param.$ref}`);
-        }
-        if (!param.schema) {
-          throw new Error(`Schema not found for parameter ${param.name}`);
-        }
-        inputs[param.name] = {
-          in: param.in,
-          schema: ""
-        };
-        additionalProperties.push(param);
+  const endpoints = {};
+  forEachOperation(config, (entry, operation) => {
+    console.log(`Processing ${entry.method} ${entry.path}`);
+    groups[entry.groupName] ??= [];
+    endpoints[entry.groupName] ??= [];
+    const inputs = {};
+    const additionalProperties = [];
+    for (const param of operation.parameters ?? []) {
+      if (isRef5(param)) {
+        throw new Error(`Found reference in parameter ${param.$ref}`);
       }
-      const security2 = operation.security ?? [];
-      const securitySchemes = config.spec.components?.securitySchemes ?? {};
-      const securityOptions = securityToOptions(security2, securitySchemes);
-      Object.assign(inputs, securityOptions);
-      additionalProperties.push(
-        ...Object.entries(securityOptions).map(
-          ([name, value]) => ({
-            name,
-            required: false,
-            schema: {
-              type: "string"
-            },
-            in: value.in
-          })
-        )
-      );
-      const types = {};
-      const shortContenTypeMap = {
-        "application/json": "json",
-        "application/x-www-form-urlencoded": "urlencoded",
-        "multipart/form-data": "formdata",
-        "application/xml": "xml",
-        "text/plain": "text"
+      if (!param.schema) {
+        throw new Error(`Schema not found for parameter ${param.name}`);
+      }
+      inputs[param.name] = {
+        in: param.in,
+        schema: ""
       };
-      let outgoingContentType;
-      if (operation.requestBody && Object.keys(operation.requestBody).length) {
-        const content = isRef(operation.requestBody) ? get2(followRef(config.spec, operation.requestBody.$ref), ["content"]) : operation.requestBody.content;
-        for (const type in content) {
-          const ctSchema = isRef(content[type].schema) ? followRef(config.spec, content[type].schema.$ref) : content[type].schema;
-          if (!ctSchema) {
-            console.warn(`Schema not found for ${type}`);
-            continue;
-          }
-          const schema = merge({}, ctSchema, {
-            required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-            properties: additionalProperties.reduce(
-              (acc, p) => ({
-                ...acc,
-                [p.name]: p.schema
-              }),
-              {}
-            )
-          });
-          Object.assign(inputs, bodyInputs(config, ctSchema));
-          types[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
-        }
-        if (content["application/json"]) {
-          outgoingContentType = "json";
-        } else if (content["application/x-www-form-urlencoded"]) {
-          outgoingContentType = "urlencoded";
-        } else if (content["multipart/form-data"]) {
-          outgoingContentType = "formdata";
-        } else {
-          outgoingContentType = "json";
-        }
-      } else {
-        const properties = additionalProperties.reduce(
-          (acc, p) => ({
-            ...acc,
-            [p.name]: p.schema
-          }),
-          {}
-        );
-        types[shortContenTypeMap["application/json"]] = zodDeserialzer.handle(
-          {
-            type: "object",
-            required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-            properties
+      additionalProperties.push(param);
+    }
+    const security2 = operation.security ?? [];
+    const securitySchemes = config.spec.components?.securitySchemes ?? {};
+    const securityOptions = securityToOptions(security2, securitySchemes);
+    Object.assign(inputs, securityOptions);
+    additionalProperties.push(
+      ...Object.entries(securityOptions).map(
+        ([name, value]) => ({
+          name,
+          required: false,
+          schema: {
+            type: "string"
           },
-          true
-        );
-      }
-      const errors = [];
-      operation.responses ??= {};
-      let foundResponse = false;
-      const output = [`import z from 'zod';`];
-      let parser = "buffered";
-      const responses = [];
-      const responsesImports = {};
-      for (const status in operation.responses) {
-        const response = isRef(
-          operation.responses[status]
-        ) ? followRef(
-          config.spec,
-          operation.responses[status].$ref
-        ) : operation.responses[status];
-        const statusCode = +status;
-        if (statusCode >= 400) {
-          errors.push(statusCdeToMessageMap[status] ?? "ProblematicResponse");
-        }
-        if (statusCode >= 200 && statusCode < 300) {
-          foundResponse = true;
-          const responseContent = get2(response, ["content"]);
-          const isJson = responseContent && responseContent["application/json"];
-          if ((response.headers ?? {})["Transfer-Encoding"]) {
-            parser = "chunked";
-          }
-          const typeScriptDeserialzer = new TypeScriptDeserialzer(
-            config.spec,
-            (schemaName, zod) => {
-              commonSchemas[schemaName] = zod;
-              responsesImports[schemaName] = {
-                defaultImport: void 0,
-                isTypeOnly: true,
-                moduleSpecifier: `../models/${config.makeImport(schemaName)}`,
-                namedImports: [{ isTypeOnly: true, name: schemaName }],
-                namespaceImport: void 0
-              };
-            }
-          );
-          const responseSchema = isJson ? typeScriptDeserialzer.handle(
-            responseContent["application/json"].schema,
-            true
-          ) : statusCode === 204 ? "void" : "ReadableStream";
-          responses.push(responseSchema);
+          in: value.in
+        })
+      )
+    );
+    const schemas = {};
+    const shortContenTypeMap = {
+      "application/json": "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 (!ctSchema) {
+          console.warn(`Schema not found for ${type}`);
+          continue;
         }
+        const schema = merge({}, ctSchema, {
+          required: additionalProperties.filter((p) => p.required).map((p) => p.name),
+          properties: additionalProperties.reduce(
+            (acc, p) => ({
+              ...acc,
+              [p.name]: p.schema
+            }),
+            {}
+          )
+        });
+        Object.assign(inputs, bodyInputs(config, ctSchema));
+        schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
       }
-      if (responses.length > 1) {
-        output.push(
-          `export type ${pascalcase(operationName + " output")} = ${removeDuplicates3(
-            responses,
-            (it) => it
-          ).join(" | ")};`
-        );
+      if (content["application/json"]) {
+        outgoingContentType = "json";
+      } else if (content["application/x-www-form-urlencoded"]) {
+        outgoingContentType = "urlencoded";
+      } else if (content["multipart/form-data"]) {
+        outgoingContentType = "formdata";
       } else {
-        output.push(
-          `export type ${pascalcase(operationName + " output")} = ${responses[0]};`
-        );
+        outgoingContentType = "json";
       }
-      output.push(
-        ...useImports(output.join(""), Object.values(responsesImports))
+    } else {
+      const properties = additionalProperties.reduce(
+        (acc, p) => ({
+          ...acc,
+          [p.name]: p.schema
+        }),
+        {}
       );
-      if (!foundResponse) {
-        output.push(
-          `export type ${pascalcase(operationName + " output")} = void`
-        );
-      }
-      outputs[`${spinalcase2(operationName)}.ts`] = output.join("\n");
-      groups[groupName].push({
-        name: operationName,
-        type: "http",
-        inputs,
-        errors: errors.length ? errors : ["ServerError"],
+      schemas[shortContenTypeMap["application/json"]] = zodDeserialzer.handle(
+        {
+          type: "object",
+          required: additionalProperties.filter((p) => p.required).map((p) => p.name),
+          properties
+        },
+        true
+      );
+    }
+    const endpoint = toEndpoint(
+      entry.groupName,
+      config.spec,
+      operation,
+      {
         outgoingContentType,
-        schemas: types,
-        parser,
-        formatOutput: () => ({
-          import: pascalcase(operationName + " output"),
-          use: pascalcase(operationName + " output")
+        name: entry.name,
+        type: "http",
+        trigger: entry,
+        schemas,
+        inputs
+      },
+      { makeImport: config.makeImport }
+    );
+    const output = [`import z from 'zod';`];
+    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};`)
+      );
+    } else {
+      output.push(`export type ${pascalcase2(entry.name + " output")} = void;`);
+    }
+    output.unshift(...useImports(output.join(""), ...responsesImports));
+    outputs[`${spinalcase2(entry.name)}.ts`] = output.join("\n");
+    endpoints[entry.groupName].push(endpoint);
+    groups[entry.groupName].push({
+      name: entry.name,
+      type: "http",
+      inputs,
+      outgoingContentType,
+      schemas,
+      trigger: entry
+    });
+  });
+  const commonSchemas = Object.values(endpoints).reduce(
+    (acc, endpoint) => ({
+      ...acc,
+      ...endpoint.reduce(
+        (acc2, { responses }) => ({
+          ...acc2,
+          ...responses.reduce(
+            (acc3, it) => ({ ...acc3, ...it.schemas }),
+            {}
+          )
         }),
-        trigger: {
-          path,
-          method
-        }
-      });
+        {}
+      )
+    }),
+    {}
+  );
+  const allSchemas = Object.keys(endpoints).map((it) => ({
+    import: `import ${camelcase2(it)} from './${config.makeImport(spinalcase2(it))}';`,
+    use: `  ...${camelcase2(it)}`
+  }));
+  const imports = [
+    'import z from "zod";',
+    `import type { ParseError } from '${config.makeImport("../http/parser")}';`,
+    `import type { ServerError } from '${config.makeImport("../http/response")}';`,
+    `import type { OutputType, Parser, Type } from '../http/send-request.ts';`
+  ];
+  return {
+    groups,
+    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")}
+};
+
+
+type Output<T extends OutputType> = T extends {
+  parser: Parser;
+  type: Type<any>;
+}
+  ? InstanceType<T['type']>
+  : T extends Type<any>
+    ? InstanceType<T>
+    : never;
+
+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']>;
+  };
+};
+
+export default schemas;
+
+
+`.trim(),
+      ...Object.fromEntries(
+        Object.entries(endpoints).map(([name, endpoint]) => {
+          const imps = importsToString(
+            ...mergeImports(
+              ...endpoint.flatMap(
+                (it) => it.responses.flatMap(
+                  (it2) => Object.values(it2.endpointImports)
+                )
+              )
+            )
+          );
+          return [
+            [
+              join("api", config.makeImport(spinalcase2(name))),
+              `${[
+                ...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))}';`
+              ].join(
+                "\n"
+              )}
+export default {
+${endpoint.flatMap((it) => it.schemas).join(",\n")}
+}`
+            ]
+          ];
+        }).flat()
+      )
     }
-  }
-  return { groups, commonSchemas, commonZod, outputs };
+  };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef(schemaOrRef)) {
-    const schema = followRef(spec, schemaOrRef.$ref);
+  if (isRef5(schemaOrRef)) {
+    const schema = followRef4(spec, schemaOrRef.$ref);
     return toProps(spec, schema, aggregator);
   } else if (schemaOrRef.type === "object") {
     for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
@@ -1164,22 +1226,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 = (getBaseUrl: () => string) :Interceptor => {\n  return {\n    before({init, url}) {\n      const baseUrl = getBaseUrl();\n      if (url.protocol === 'local:') {\n        return {init, url: new URL(url.pathname, baseUrl)}\n      }\n      return {init, url}\n    },\n  };\n};\n\nexport const logInterceptor = {\n  before(request: Request) {\n    console.log('Request', request);\n    return request;\n  },\n  after(response: 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 = "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";
 
 // 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\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';
 
 // packages/typescript/src/lib/http/parser.txt
-var parser_default = "import { z } from 'zod';\n\nexport type ParseError<T extends z.ZodType<any, any, any>> = {\n  kind: 'parse';\n} & z.inferFlattenedErrors<T>;\n\nexport function parse<T extends z.ZodType>(\n  schema: T,\n  input: unknown,\n) {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const errors = result.error.flatten((issue) => issue);\n    return [null, errors];\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 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';
 
 // 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";
 
 // packages/typescript/src/lib/http/response.txt
-var response_default = "export interface ApiResponse<Status extends number, Body extends unknown> {\n  kind: 'response';\n  status: Status;\n  body: Body;\n}\n\n// 4xx Client Errors\nexport type BadRequest = ApiResponse<400, { message: string }>;\nexport type Unauthorized = ApiResponse<401, { message: string }>;\nexport type PaymentRequired = ApiResponse<402, { message: string }>;\nexport type Forbidden = ApiResponse<403, { message: string }>;\nexport type NotFound = ApiResponse<404, { message: string }>;\nexport type MethodNotAllowed = ApiResponse<405, { message: string }>;\nexport type NotAcceptable = ApiResponse<406, { message: string }>;\nexport type Conflict = ApiResponse<409, { message: string }>;\nexport type Gone = ApiResponse<410, { message: string }>;\nexport type UnprocessableEntity = ApiResponse<422, { message: string; errors?: Record<string, string[]> }>;\nexport type TooManyRequests = ApiResponse<429, { message: string; retryAfter?: string }>;\nexport type PayloadTooLarge = ApiResponse<413, { message: string; }>;\nexport type UnsupportedMediaType = ApiResponse<415, { message: string; }>;\n\n// 5xx Server Errors\nexport type InternalServerError = ApiResponse<500, { message: string }>;\nexport type NotImplemented = ApiResponse<501, { message: string }>;\nexport type BadGateway = ApiResponse<502, { message: string }>;\nexport type ServiceUnavailable = ApiResponse<503, { message: string; retryAfter?: string }>;\nexport type GatewayTimeout = ApiResponse<504, { message: string }>;\n\nexport type ClientError =\n  | BadRequest\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\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";
 
 // packages/typescript/src/lib/http/send-request.txt
-var send_request_default = "\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => RequestConfig;\n  deserializer: (response: Response) => Promise<unknown> | unknown;\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)(new Request(config.url, config.init), {\n    ...config.init,\n    signal: options.signal,\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  if (response.ok) {\n    const data = await route.deserializer(response);\n    return [data as never, null] as const;\n  }\n  const error = await handleError(response);\n  return [null as never, { ...error, kind: 'response' }] as const;\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> };\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";
 
 // packages/typescript/src/lib/generate.ts
 function security(spec) {
@@ -1207,21 +1269,14 @@ async function generate(spec, settings) {
   const makeImport = (moduleSpecifier) => {
     return settings.useTsExtension ? `${moduleSpecifier}.ts` : moduleSpecifier;
   };
-  const { commonSchemas, groups, outputs, commonZod } = generateCode({
+  const { commonSchemas, endpoints, groups, outputs, commonZod, clientFiles } = generateCode({
     spec,
     style: "github",
-    target: "javascript",
     makeImport
   });
-  const output = settings.mode === "full" ? join(settings.output, "src") : settings.output;
+  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   const options = security(spec);
-  const clientFiles = generateSDK({
-    name: settings.name || "Client",
-    operations: groups,
-    servers: spec.servers?.map((server) => server.url) || [],
-    options,
-    makeImport
-  });
+  const clientName = settings.name || "Client";
   const inputFiles = generateInputs(groups, commonZod, makeImport);
   await writeFiles(output, {
     "outputs/.gitkeep": "",
@@ -1229,24 +1284,33 @@ async function generate(spec, settings) {
     "models/.getkeep": ""
     // 'README.md': readme,
   });
-  await writeFiles(join(output, "http"), {
+  await writeFiles(join2(output, "http"), {
     "interceptors.ts": interceptors_default,
     "parse-response.ts": parse_response_default,
     "send-request.ts": `import z from 'zod';
 import type { Interceptor } from './${makeImport("interceptors")}';
-import { handleError } from './${makeImport("parse-response")}';
+import { buffered } from './${makeImport("parse-response")}';
 import { parse } from './${makeImport("parser")}';
-import type { RequestConfig } from './request.ts';
+import type { RequestConfig } from './${makeImport("request")}';
+import { APIResponse } from './${makeImport("response")}';
+
 ${send_request_default}`,
     "response.ts": response_default,
     "parser.ts": parser_default,
     "request.ts": request_default
   });
-  await writeFiles(join(output, "outputs"), outputs);
+  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,
     ...inputFiles,
+    ...endpoints,
     ...Object.fromEntries(
       Object.entries(commonSchemas).map(([name, schema]) => [
         `models/${name}.ts`,
@@ -1261,29 +1325,36 @@ ${send_request_default}`,
     )
   });
   const folders = [
-    getFolderExports(join(output, "outputs"), settings.useTsExtension),
+    getFolderExports(join2(output, "outputs"), settings.useTsExtension),
     getFolderExports(
-      join(output, "inputs"),
+      join2(output, "inputs"),
       settings.useTsExtension,
       ["ts"],
-      (dirent) => dirent.isDirectory() && dirent.name === "schemas"
+      (dirent) => dirent.isDirectory() && ["schemas"].includes(dirent.name)
     ),
-    getFolderExports(join(output, "http"), settings.useTsExtension)
+    getFolderExports(join2(output, "api"), settings.useTsExtension),
+    getFolderExports(
+      join2(output, "http"),
+      settings.useTsExtension,
+      ["ts"],
+      (dirent) => dirent.name !== "response.ts"
+    )
   ];
   if (modelsImports.length) {
     folders.push(
-      getFolderExports(join(output, "models"), settings.useTsExtension)
+      getFolderExports(join2(output, "models"), settings.useTsExtension)
     );
   }
-  const [outputIndex, inputsIndex, httpIndex, modelsIndex] = await Promise.all(folders);
+  const [outputIndex, inputsIndex, apiIndex, httpIndex, modelsIndex] = await Promise.all(folders);
   await writeFiles(output, {
+    "api/index.ts": apiIndex,
     "outputs/index.ts": outputIndex,
     "inputs/index.ts": inputsIndex || null,
     "http/index.ts": httpIndex,
     ...modelsImports.length ? { "models/index.ts": modelsIndex } : {}
   });
   await writeFiles(output, {
-    "index.ts": await getFolderExports(output, settings.useTsExtension)
+    "index.ts": await getFolderExports(output, settings.useTsExtension, ["ts"])
   });
   if (settings.mode === "full") {
     await writeFiles(settings.output, {
@@ -1291,7 +1362,7 @@ ${send_request_default}`,
         ignoreIfExists: true,
         content: JSON.stringify(
           {
-            name: "sdk",
+            name: settings.name ? `@${spinalcase3(clientName.toLowerCase())}/sdk` : "sdk",
             type: "module",
             main: "./src/index.ts",
             dependencies: {