@sdk-it/typescript 0.7.0 → 0.8.1

package/dist/index.js

@@ -6,6 +6,7 @@ import { npmRunPathEnv } from "npm-run-path";
 import ts, { TypeFlags, symbolName } from "typescript";
 import debug from "debug";
 import ts2 from "typescript";
+import "lodash-es";
 import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname as dirname2, isAbsolute, join as join2 } from "node:path";
 var deriveSymbol = Symbol.for("serialize");
@@ -45,7 +46,7 @@ async function getFolderExports(folder, extensions = ["ts"]) {
   const exports = [];
   for (const file of files) {
     if (file.isDirectory()) {
-      exports.push(`export * from './${file.name}';`);
+      exports.push(`export * from './${file.name}/index.ts';`);
     } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
       exports.push(`export * from './${file.name}';`);
     }
@@ -77,259 +78,8 @@ function toLitObject(obj, accessor = (value) => value) {
 import { get as get2, merge } from "lodash-es";
 import { camelcase as camelcase2, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
 
-// packages/typescript/src/lib/json-zod.ts
+// packages/typescript/src/lib/utils.ts
 import { get } from "lodash-es";
-function cleanRef(ref) {
-  return ref.replace(/^#\//, "");
-}
-function parseRef(ref) {
-  const parts = ref.split(ref);
-  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);
-  }
-  return entry;
-}
-function jsonSchemaToZod(spec, schema, required = false, onRef, circularRefTracker = /* @__PURE__ */ new Set()) {
-  if ("$ref" in schema) {
-    const schemaName = cleanRef(schema.$ref).split("/").pop();
-    if (circularRefTracker.has(schemaName)) {
-      return schemaName;
-    }
-    circularRefTracker.add(schemaName);
-    onRef(
-      schemaName,
-      jsonSchemaToZod(
-        spec,
-        followRef(spec, schema.$ref),
-        required,
-        onRef,
-        circularRefTracker
-      )
-    );
-    circularRefTracker.delete(schemaName);
-    return schemaName;
-  }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    const allOfSchemas = schema.allOf.map(
-      (sub) => jsonSchemaToZod(spec, sub, true, onRef, circularRefTracker)
-    );
-    return allOfSchemas.length ? `z.intersection(${allOfSchemas.join(", ")})` : allOfSchemas[0];
-  }
-  if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const anyOfSchemas = schema.anyOf.map(
-      (sub) => jsonSchemaToZod(spec, sub, false, onRef, circularRefTracker)
-    );
-    return anyOfSchemas.length > 1 ? `z.union([${anyOfSchemas.join(", ")}])${appendOptional(required)}` : (
-      // Handle an invalid anyOf with one schema
-      anyOfSchemas[0]
-    );
-  }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const oneOfSchemas = schema.oneOf.map((sub) => {
-      if ("$ref" in sub) {
-        const { model } = parseRef(sub.$ref);
-        if (circularRefTracker.has(model)) {
-          return model;
-        }
-      }
-      return jsonSchemaToZod(spec, sub, false, onRef, circularRefTracker);
-    });
-    return oneOfSchemas.length > 1 ? `z.union([${oneOfSchemas.join(", ")}])${appendOptional(required)}` : (
-      // Handle an invalid oneOf with one schema
-      oneOfSchemas[0]
-    );
-  }
-  if (schema.enum && Array.isArray(schema.enum)) {
-    const enumVals = schema.enum.map((val) => JSON.stringify(val)).join(", ");
-    return `z.enum([${enumVals}])${appendOptional(required)}`;
-  }
-  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-  if (!types.length) {
-    return `z.unknown()${appendOptional(required)}`;
-  }
-  if (types.length > 1) {
-    const realTypes = types.filter((t) => t !== "null");
-    if (realTypes.length === 1 && types.includes("null")) {
-      const typeZod = basicTypeToZod(
-        realTypes[0],
-        schema,
-        spec,
-        false,
-        onRef,
-        circularRefTracker
-      );
-      return `${typeZod}.nullable()${appendOptional(required)}`;
-    }
-    const subSchemas = types.map(
-      (t) => basicTypeToZod(t, schema, spec, false, onRef, circularRefTracker)
-    );
-    return `z.union([${subSchemas.join(", ")}])${appendOptional(required)}`;
-  }
-  return basicTypeToZod(
-    types[0],
-    schema,
-    spec,
-    required,
-    onRef,
-    circularRefTracker
-  );
-}
-function basicTypeToZod(type, schema, spec, required = false, onRef, refProcessingStack) {
-  switch (type) {
-    case "string":
-      return handleString(schema, required);
-    case "number":
-    case "integer":
-      return handleNumber(schema, required);
-    case "boolean":
-      return `z.boolean()${appendDefault(schema.default)}${appendOptional(required)}`;
-    case "object":
-      return handleObject(schema, spec, required, onRef, refProcessingStack);
-    case "array":
-      return handleArray(schema, spec, required, onRef, refProcessingStack);
-    case "null":
-      return `z.null()${appendOptional(required)}`;
-    default:
-      return `z.unknown()${appendOptional(required)}`;
-  }
-}
-function handleString(schema, required) {
-  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}${appendDefault(schema.default)}${appendOptional(required)}`;
-}
-function handleNumber(schema, required) {
-  let defaultValue = schema.default !== void 0 ? `.default(${schema.default})` : ``;
-  let base = "z.number()";
-  if (schema.format === "int64") {
-    base = "z.bigint()";
-    if (schema.default !== void 0) {
-      defaultValue = `.default(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})`;
-  }
-  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}${appendOptional(required)}`;
-}
-function handleObject(schema, spec, required = false, onRef, refProcessingStack) {
-  const properties = schema.properties || {};
-  const propEntries = Object.entries(properties).map(([key, propSchema]) => {
-    const isRequired = (schema.required ?? []).includes(key);
-    const zodPart = jsonSchemaToZod(
-      spec,
-      propSchema,
-      isRequired,
-      onRef,
-      refProcessingStack
-    );
-    return `'${key}': ${zodPart}`;
-  });
-  let additionalProps = "";
-  if (schema.additionalProperties) {
-    if (typeof schema.additionalProperties === "object") {
-      const addPropZod = jsonSchemaToZod(
-        spec,
-        schema.additionalProperties,
-        true,
-        onRef,
-        refProcessingStack
-      );
-      additionalProps = `.catchall(${addPropZod})`;
-    } else if (schema.additionalProperties === true) {
-      additionalProps = `.catchall(z.unknown())`;
-    }
-  }
-  const objectSchema = `z.object({${propEntries.join(", ")}})${additionalProps}`;
-  return `${objectSchema}${appendOptional(required)}`;
-}
-function handleArray(schema, spec, required = false, onRef, refProcessingStack) {
-  const { items } = schema;
-  if (!items) {
-    return `z.array(z.unknown())${appendOptional(required)}`;
-  }
-  if (Array.isArray(items)) {
-    const tupleItems = items.map(
-      (sub) => jsonSchemaToZod(spec, sub, true, onRef, refProcessingStack)
-    );
-    const base = `z.tuple([${tupleItems.join(", ")}])`;
-    return `${base}${appendOptional(required)}`;
-  }
-  const itemsSchema = jsonSchemaToZod(
-    spec,
-    items,
-    true,
-    onRef,
-    refProcessingStack
-  );
-  return `z.array(${itemsSchema})${appendOptional(required)}`;
-}
-function appendOptional(isRequired) {
-  return isRequired ? "" : ".optional()";
-}
-function appendDefault(defaultValue) {
-  return defaultValue !== void 0 ? `.default(${JSON.stringify(defaultValue)})` : "";
-}
 
 // packages/typescript/src/lib/sdk.ts
 import { camelcase, pascalcase, spinalcase } from "stringcase";
@@ -455,7 +205,6 @@ function generateClientSdk(spec) {
   const emitter = new Emitter();
   const streamEmitter = new StreamEmitter();
   const schemas = {};
-  const schemasImports = [];
   const schemaEndpoint = new SchemaEndpoint();
   const errors = [];
   for (const [name, operations] of Object.entries(spec.operations)) {
@@ -474,9 +223,6 @@ function generateClientSdk(spec) {
       const schemaName = camelcase(`${operation.name} schema`);
       const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject(operation.schemas)};`;
       schemas[featureSchemaFileName].push(schema);
-      schemasImports.push(
-        ...operation.imports.map((it) => (it.namedImports ?? []).map((it2) => it2.name)).flat()
-      );
       const schemaRef = `${featureSchemaFileName}.${schemaName}`;
       const output = operation.formatOutput();
       const inputHeaders = [];
@@ -506,7 +252,7 @@ function generateClientSdk(spec) {
         const input = `z.infer<typeof ${schemaRef}>`;
         const endpoint = `${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
         streamEmitter.addImport(
-          `import type {${pascalcase(operation.name)}} from './outputs/${spinalcase(operation.name)}';`
+          `import type {${pascalcase(operation.name)}} from './outputs/${spinalcase(operation.name)}.ts';`
         );
         streamEmitter.addEndpoint(
           endpoint,
@@ -529,7 +275,7 @@ function generateClientSdk(spec) {
         );
       } else {
         emitter.addImport(
-          `import type {${output.import}} from './outputs/${spinalcase(operation.name)}';`
+          `import type {${output.import}} from './outputs/${spinalcase(operation.name)}.ts';`
         );
         errors.push(...operation.errors ?? []);
         const addTypeParser = Object.keys(operation.schemas).length > 1;
@@ -571,7 +317,9 @@ function generateClientSdk(spec) {
       Object.entries(schemas).map(([key, value]) => [
         `inputs/${key}.ts`,
         [
-          schemasImports.length ? `import {${removeDuplicates(schemasImports, (it) => it)}} from '../zod';` : "",
+          // schemasImports.length
+          //   ? `import {${removeDuplicates(schemasImports, (it) => it)}} from '../zod';`
+          //   : '',
           spec.commonZod ? 'import * as commonZod from "../zod.ts";' : "",
           ...value
         ].map((it) => it.trim()).filter(Boolean).join("\n") + "\n"
@@ -588,6 +336,22 @@ function generateClientSdk(spec) {
 function isRef(obj) {
   return "$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);
+  }
+  return entry;
+}
 function securityToOptions(security2, securitySchemas, staticIn) {
   securitySchemas ??= {};
   const options = {};
@@ -621,6 +385,447 @@ function securityToOptions(security2, securitySchemas, staticIn) {
   }
   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);
+    }
+  }
+  return Object.values(merged);
+}
+function importsToString(...imports) {
+  return imports.map((it) => {
+    if (it.defaultImport) {
+      return `import ${it.defaultImport} from '${it.moduleSpecifier}'`;
+    }
+    if (it.namespaceImport) {
+      return `import * as ${it.namespaceImport} from '${it.moduleSpecifier}'`;
+    }
+    if (it.namedImports) {
+      return `import {${removeDuplicates(it.namedImports, (it2) => it2.name).map((n) => `${n.isTypeOnly ? "type" : ""} ${n.name}`).join(", ")}} from '${it.moduleSpecifier}'`;
+    }
+    throw new Error(`Invalid import ${JSON.stringify(it)}`);
+  });
+}
+
+// packages/typescript/src/lib/emitters/interface.ts
+var TypeScriptDeserialzer = class {
+  circularRefTracker = /* @__PURE__ */ new Set();
+  #spec;
+  #onRef;
+  constructor(spec, onRef) {
+    this.#spec = spec;
+    this.#onRef = onRef;
+  }
+  /**
+   * Handle objects (properties)
+   */
+  object(schema, required = false) {
+    const properties = schema.properties || {};
+    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
+      const isRequired = (schema.required ?? []).includes(key);
+      const tsType = this.handle(propSchema, isRequired);
+      return `${key}: ${tsType}`;
+    });
+    if (schema.additionalProperties) {
+      if (typeof schema.additionalProperties === "object") {
+        const indexType = this.handle(schema.additionalProperties, true);
+        propEntries.push(`[key: string]: ${indexType}`);
+      } else if (schema.additionalProperties === true) {
+        propEntries.push("[key: string]: any");
+      }
+    }
+    return `{ ${propEntries.join("; ")} }`;
+  }
+  /**
+   * Handle arrays (items could be a single schema or a tuple)
+   */
+  array(schema, required = false) {
+    const { items } = schema;
+    if (!items) {
+      return "any[]";
+    }
+    if (Array.isArray(items)) {
+      const tupleItems = items.map((sub) => this.handle(sub, true));
+      return `[${tupleItems.join(", ")}]`;
+    }
+    const itemsType = this.handle(items, true);
+    return `${itemsType}[]`;
+  }
+  /**
+   * Convert a basic type (string | number | boolean | object | array, etc.) to TypeScript
+   */
+  normal(type, schema, required = false) {
+    switch (type) {
+      case "string":
+        return this.string(schema, required);
+      case "number":
+      case "integer":
+        return this.number(schema, required);
+      case "boolean":
+        return appendOptional("boolean", required);
+      case "object":
+        return this.object(schema, required);
+      case "array":
+        return this.array(schema, required);
+      case "null":
+        return "null";
+      default:
+        return appendOptional("any", 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), true));
+    this.circularRefTracker.delete(schemaName);
+    return appendOptional(schemaName, required);
+  }
+  allOf(schemas) {
+    const allOfTypes = schemas.map((sub) => this.handle(sub, true));
+    return allOfTypes.length > 1 ? `${allOfTypes.join(" & ")}` : allOfTypes[0];
+  }
+  anyOf(schemas, required) {
+    const anyOfTypes = schemas.map((sub) => this.handle(sub, true));
+    return appendOptional(
+      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 (this.circularRefTracker.has(model)) {
+          return model;
+        }
+      }
+      return this.handle(sub, false);
+    });
+    return appendOptional(
+      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);
+  }
+  /**
+   * Handle string type with formats
+   */
+  string(schema, required) {
+    let type;
+    switch (schema.format) {
+      case "date-time":
+      case "datetime":
+      case "date":
+        type = "Date";
+        break;
+      case "binary":
+      case "byte":
+        type = "Blob";
+        break;
+      case "int64":
+        type = "bigint";
+        break;
+      default:
+        type = "string";
+    }
+    return appendOptional(type, required);
+  }
+  /**
+   * Handle number/integer types with formats
+   */
+  number(schema, required) {
+    const type = schema.format === "int64" ? "bigint" : "number";
+    return appendOptional(type, required);
+  }
+  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);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.oneOf(schema.oneOf, required);
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      return this.enum(schema.enum, required);
+    }
+    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    if (!types.length) {
+      return appendOptional("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);
+      }
+      const typeResults = types.map((t) => this.normal(t, schema, false));
+      return appendOptional(typeResults.join(" | "), required);
+    }
+    return this.normal(types[0], schema, required);
+  }
+  /**
+   * Generate an interface declaration
+   */
+  generateInterface(name, schema) {
+    const content = this.handle(schema, true);
+    return `interface ${name} ${content}`;
+  }
+};
+function appendOptional(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)}`;
+  }
+  // oneOf() {}
+  // enum() {}
+  /**
+   * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
+   * We'll also handle .optional() if needed.
+   */
+  normal(type, schema, required = false) {
+    switch (type) {
+      case "string":
+        return this.string(schema, required);
+      case "number":
+      case "integer":
+        return this.number(schema, required);
+      case "boolean":
+        return `z.boolean()${appendDefault(schema.default)}${appendOptional2(required)}`;
+      case "object":
+        return this.object(schema, required);
+      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));
+    return allOfSchemas.length ? `z.intersection(${allOfSchemas.join(", ")})` : allOfSchemas[0];
+  }
+  anyOf(schemas, required) {
+    const anyOfSchemas = schemas.map((sub) => this.handle(sub, false));
+    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 ("$ref" in sub) {
+        const { model } = parseRef(sub.$ref);
+        if (this.circularRefTracker.has(model)) {
+          return model;
+        }
+      }
+      return this.handle(sub, false);
+    });
+    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(", ");
+    return `z.enum([${enumVals}])${appendOptional2(required)}`;
+  }
+  /**
+   * Handle a `string` schema with possible format keywords (JSON Schema).
+   */
+  string(schema, required) {
+    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}${appendDefault(schema.default)}${appendOptional2(required)}`;
+  }
+  /**
+   * 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, required) {
+    let defaultValue = schema.default !== void 0 ? `.default(${schema.default})` : ``;
+    let base = "z.number()";
+    if (schema.format === "int64") {
+      base = "z.bigint()";
+      if (schema.default !== void 0) {
+        defaultValue = `.default(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})`;
+    }
+    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}${appendOptional2(required)}`;
+  }
+  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);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.oneOf(schema.oneOf ?? [], required);
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      return this.enum(schema.enum, required);
+    }
+    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    if (!types.length) {
+      return `z.unknown()${appendOptional2(required)}`;
+    }
+    if (types.length > 1) {
+      const realTypes = types.filter((t) => t !== "null");
+      if (realTypes.length === 1 && types.includes("null")) {
+        const typeZod = this.normal(realTypes[0], schema, false);
+        return `${typeZod}.nullable()${appendOptional2(required)}`;
+      }
+      const subSchemas = types.map((t) => this.normal(t, schema, false));
+      return `z.union([${subSchemas.join(", ")}])${appendOptional2(required)}`;
+    }
+    return this.normal(types[0], schema, required);
+  }
+};
+function appendOptional2(isRequired) {
+  return isRequired ? "" : ".optional()";
+}
+function appendDefault(defaultValue) {
+  return defaultValue !== void 0 ? `.default(${JSON.stringify(defaultValue)})` : "";
+}
 
 // packages/typescript/src/lib/generator.ts
 var responses = {
@@ -653,8 +858,10 @@ var defaults = {
   }
 };
 function generateCode(config) {
-  const groups = {};
+  const imports = [];
   const commonSchemas = {};
+  const zodDeserialzer = new ZodDeserialzer(config.spec);
+  const groups = {};
   const outputs = {};
   for (const [path, methods2] of Object.entries(config.spec.paths ?? {})) {
     for (const [method, operation] of Object.entries(methods2)) {
@@ -664,7 +871,6 @@ function generateCode(config) {
       const groupName = (operation.tags ?? ["unknown"])[0];
       groups[groupName] ??= [];
       const inputs = {};
-      const imports = [];
       const additionalProperties = [];
       for (const param of operation.parameters ?? []) {
         if (isRef(param)) {
@@ -707,31 +913,18 @@ function generateCode(config) {
       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 schema = isRef(content[type].schema) ? followRef(config.spec, content[type].schema.$ref) : content[type].schema;
-          types[shortContenTypeMap[type]] = jsonSchemaToZod(
-            config.spec,
-            merge(schema, {
-              required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-              properties: additionalProperties.reduce(
-                (acc, p) => ({
-                  ...acc,
-                  [p.name]: p.schema
-                }),
-                {}
-              )
-            }),
-            true,
-            (schemaName, zod) => {
-              commonSchemas[schemaName] = zod;
-              imports.push({
-                defaultImport: void 0,
-                isTypeOnly: false,
-                moduleSpecifier: "../zod",
-                namedImports: [{ isTypeOnly: false, name: schemaName }],
-                namespaceImport: void 0
-              });
-            }
-          );
+          const ctSchema = isRef(content[type].schema) ? followRef(config.spec, content[type].schema.$ref) : content[type].schema;
+          const schema = merge(ctSchema, {
+            required: additionalProperties.filter((p) => p.required).map((p) => p.name),
+            properties: additionalProperties.reduce(
+              (acc, p) => ({
+                ...acc,
+                [p.name]: p.schema
+              }),
+              {}
+            )
+          });
+          types[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
         }
         if (content["application/json"]) {
           contentType = "json";
@@ -743,30 +936,20 @@ function generateCode(config) {
           contentType = "json";
         }
       } else {
-        types[shortContenTypeMap["application/json"]] = jsonSchemaToZod(
-          config.spec,
+        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.reduce(
-              (acc, p) => ({
-                ...acc,
-                [p.name]: p.schema
-              }),
-              {}
-            )
+            properties
           },
-          true,
-          (schemaName, zod) => {
-            commonSchemas[schemaName] = zod;
-            imports.push({
-              defaultImport: void 0,
-              isTypeOnly: false,
-              moduleSpecifier: "./zod",
-              namedImports: [{ isTypeOnly: false, name: schemaName }],
-              namespaceImport: void 0
-            });
-          }
+          true
         );
       }
       const errors = [];
@@ -783,48 +966,57 @@ function generateCode(config) {
           foundResponse = true;
           const responseContent = get2(response, ["content"]);
           const isJson = responseContent && responseContent["application/json"];
-          const responseSchema = isJson ? jsonSchemaToZod(
+          const imports2 = [];
+          const typeScriptDeserialzer = new TypeScriptDeserialzer(
             config.spec,
-            responseContent["application/json"].schema,
-            true,
             (schemaName, zod) => {
               commonSchemas[schemaName] = zod;
-              imports.push({
+              imports2.push({
                 defaultImport: void 0,
-                isTypeOnly: false,
-                moduleSpecifier: "../zod",
-                namedImports: [{ isTypeOnly: false, name: schemaName }],
+                isTypeOnly: true,
+                moduleSpecifier: `../models/${schemaName}.ts`,
+                namedImports: [{ isTypeOnly: true, name: schemaName }],
                 namespaceImport: void 0
               });
             }
-          ) : "z.instanceof(ReadableStream)";
-          output.push(
-            importsToString(mergeImports(Object.values(imports).flat())).join(
-              "\n"
-            )
           );
+          const responseSchema = isJson ? typeScriptDeserialzer.handle(
+            responseContent["application/json"].schema,
+            true
+          ) : "ReadableStream";
+          for (const it of mergeImports(imports2)) {
+            const singleImport = it.defaultImport ?? it.namespaceImport;
+            if (singleImport && responseSchema.includes(singleImport)) {
+              output.push(importsToString(it).join("\n"));
+            } else if (it.namedImports.length) {
+              for (const namedImport of it.namedImports) {
+                if (responseSchema.includes(namedImport.name)) {
+                  output.push(importsToString(it).join("\n"));
+                }
+              }
+            }
+          }
           output.push(
-            `export const ${pascalcase2(operationName + " output")} = ${responseSchema}`
+            `export type ${pascalcase2(operationName + " output")} = ${responseSchema}`
           );
         }
       }
       if (!foundResponse) {
         output.push(
-          `export const ${pascalcase2(operationName + " output")} = z.void()`
+          `export type ${pascalcase2(operationName + " output")} = void`
         );
       }
       outputs[`${spinalcase2(operationName)}.ts`] = output.join("\n");
       groups[groupName].push({
         name: operationName,
         type: "http",
-        imports: mergeImports(Object.values(imports).flat()),
         inputs,
         errors: errors.length ? errors : ["ServerError"],
         contentType,
         schemas: types,
         formatOutput: () => ({
           import: pascalcase2(operationName + " output"),
-          use: `z.infer<typeof ${pascalcase2(operationName + " output")}>`
+          use: pascalcase2(operationName + " output")
         }),
         trigger: {
           path,
@@ -835,35 +1027,6 @@ function generateCode(config) {
   }
   return { groups, commonSchemas, outputs };
 }
-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);
-    }
-  }
-  return Object.values(merged);
-}
-function importsToString(imports) {
-  return imports.map((i) => {
-    if (i.defaultImport) {
-      return `import ${i.defaultImport} from '${i.moduleSpecifier}'`;
-    }
-    if (i.namespaceImport) {
-      return `import * as ${i.namespaceImport} from '${i.moduleSpecifier}'`;
-    }
-    if (i.namedImports) {
-      return `import {${removeDuplicates(i.namedImports, (it) => it.name).map((n) => n.name).join(", ")}} from '${i.moduleSpecifier}'`;
-    }
-    throw new Error(`Invalid import ${JSON.stringify(i)}`);
-  });
-}
 
 // packages/typescript/src/lib/http/client.txt
 var client_default2 = "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 async function parseResponse(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  const isChunked = response.headers.get('Transfer-Encoding') === 'chunked';\n  if (isChunked) {\n    return response.body!;\n    // return handleChunkedResponse(response, contentType);\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";
@@ -872,13 +1035,13 @@ var client_default2 = "import { parse } from 'fast-content-type-parse';\n\nexpor
 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";
 
 // packages/typescript/src/lib/http/request.txt
-var request_default = "type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\ntype ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart';\ntype Endpoint = `${ContentType} ${Method} ${string}` | `${Method} ${string}`;\n\nexport function createUrl(base: string, path: string, query: URLSearchParams) {\n  const url = new URL(path, base);\n  url.search = query.toString();\n  return url;\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\ninterface ToRequest {\n  <T extends Endpoint>(\n    endpoint: T,\n    input: Record<string, any>,\n    props: {\n      inputHeaders: string[];\n      inputQuery: string[];\n      inputBody: string[];\n      inputParams: string[];\n    },\n    defaults: {\n      baseUrl: string;\n      headers?: Partial<Record<string, string>>;\n    },\n  ): Request;\n  urlencoded: <T extends Endpoint>(\n    endpoint: T,\n    input: Record<string, any>,\n    props: {\n      inputHeaders: string[];\n      inputQuery: string[];\n      inputBody: string[];\n      inputParams: string[];\n    },\n    defaults: {\n      baseUrl: string;\n      headers?: Partial<Record<string, string>>;\n    },\n  ) => Request;\n}\n\nfunction _json(\n  input: Record<string, any>,\n  props: {\n    inputHeaders: string[];\n    inputQuery: string[];\n    inputBody: string[];\n    inputParams: string[];\n  },\n) {\n  const headers = new Headers({});\n  for (const header of props.inputHeaders) {\n    headers.set(header, input[header]);\n  }\n\n  const body: Record<string, any> = {};\n  for (const prop of props.inputBody) {\n    body[prop] = input[prop];\n  }\n\n  const query = new URLSearchParams();\n  for (const key of props.inputQuery) {\n    const value = input[key];\n    if (value !== undefined) {\n      query.set(key, String(value));\n    }\n  }\n\n  const params = props.inputParams.reduce<Record<string, any>>((acc, key) => {\n    acc[key] = input[key];\n    return acc;\n  }, {});\n\n  return {\n    body: JSON.stringify(body),\n    query,\n    params,\n    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },\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  constructor(\n    protected input: Input,\n    protected props: Props,\n  ) {}\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Partial<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: Partial<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 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 formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function _urlencoded(\n  input: Record<string, any>,\n  props: {\n    inputHeaders: string[];\n    inputQuery: string[];\n    inputBody: string[];\n    inputParams: string[];\n  },\n) {\n  const headers = new Headers({});\n  for (const header of props.inputHeaders) {\n    headers.set(header, input[header]);\n  }\n\n  const body = new URLSearchParams();\n  for (const prop of props.inputBody) {\n    body.set(prop, input[prop]);\n  }\n\n  const query = new URLSearchParams();\n  for (const key of props.inputQuery) {\n    const value = input[key];\n    if (value !== undefined) {\n      query.set(key, String(value));\n    }\n  }\n\n  const params = props.inputParams.reduce<Record<string, any>>((acc, key) => {\n    acc[key] = input[key];\n    return acc;\n  }, {});\n\n  return {\n    body,\n    query,\n    params,\n    headers: {},\n  };\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n  defaults: {\n    baseUrl: string;\n    headers?: Partial<Record<string, string>>;\n  },\n): Request {\n  const [method, path] = endpoint.split(' ');\n\n  const headers = new Headers(\n    Object.entries({\n      ...defaults?.headers,\n      ...input.headers,\n    }).filter(truthyEntry),\n  );\n  const pathVariable = template(path, input.params);\n\n  const url = createUrl(defaults.baseUrl, pathVariable, input.query);\n  return new Request(url, {\n    method: method,\n    headers: headers,\n    body: method === 'GET' ? undefined : input.body,\n  });\n}\n\nfunction truthyEntry(entry: [string, unknown]): entry is [string, string] {\n  return entry[1] !== undefined;\n}\n";
+var request_default = "type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\ntype ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart';\ntype Endpoint = `${ContentType} ${Method} ${string}` | `${Method} ${string}`;\nexport type BodyInit =\n  | ArrayBuffer\n  | AsyncIterable<Uint8Array>\n  | Blob\n  | FormData\n  | Iterable<Uint8Array>\n  | NodeJS.ArrayBufferView\n  | URLSearchParams\n  | null\n  | string;\n\nexport function createUrl(base: string, path: string, query: URLSearchParams) {\n  const url = new URL(path, base);\n  url.search = query.toString();\n  return url;\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\ninterface ToRequest {\n  <T extends Endpoint>(\n    endpoint: T,\n    input: Record<string, any>,\n    props: {\n      inputHeaders: string[];\n      inputQuery: string[];\n      inputBody: string[];\n      inputParams: string[];\n    },\n    defaults: {\n      baseUrl: string;\n      headers?: Partial<Record<string, string>>;\n    },\n  ): Request;\n  urlencoded: <T extends Endpoint>(\n    endpoint: T,\n    input: Record<string, any>,\n    props: {\n      inputHeaders: string[];\n      inputQuery: string[];\n      inputBody: string[];\n      inputParams: string[];\n    },\n    defaults: {\n      baseUrl: string;\n      headers?: Partial<Record<string, string>>;\n    },\n  ) => Request;\n}\n\nfunction _json(\n  input: Record<string, any>,\n  props: {\n    inputHeaders: string[];\n    inputQuery: string[];\n    inputBody: string[];\n    inputParams: string[];\n  },\n) {\n  const headers = new Headers({});\n  for (const header of props.inputHeaders) {\n    headers.set(header, input[header]);\n  }\n\n  const body: Record<string, any> = {};\n  for (const prop of props.inputBody) {\n    body[prop] = input[prop];\n  }\n\n  const query = new URLSearchParams();\n  for (const key of props.inputQuery) {\n    const value = input[key];\n    if (value !== undefined) {\n      query.set(key, String(value));\n    }\n  }\n\n  const params = props.inputParams.reduce<Record<string, any>>((acc, key) => {\n    acc[key] = input[key];\n    return acc;\n  }, {});\n\n  return {\n    body: JSON.stringify(body),\n    query,\n    params,\n    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },\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  constructor(\n    protected input: Input,\n    protected props: Props,\n  ) {}\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Partial<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: Partial<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 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 formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function _urlencoded(\n  input: Record<string, any>,\n  props: {\n    inputHeaders: string[];\n    inputQuery: string[];\n    inputBody: string[];\n    inputParams: string[];\n  },\n) {\n  const headers = new Headers({});\n  for (const header of props.inputHeaders) {\n    headers.set(header, input[header]);\n  }\n\n  const body = new URLSearchParams();\n  for (const prop of props.inputBody) {\n    body.set(prop, input[prop]);\n  }\n\n  const query = new URLSearchParams();\n  for (const key of props.inputQuery) {\n    const value = input[key];\n    if (value !== undefined) {\n      query.set(key, String(value));\n    }\n  }\n\n  const params = props.inputParams.reduce<Record<string, any>>((acc, key) => {\n    acc[key] = input[key];\n    return acc;\n  }, {});\n\n  return {\n    body,\n    query,\n    params,\n    headers: {},\n  };\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n  defaults: {\n    baseUrl: string;\n    headers?: Partial<Record<string, string>>;\n  },\n): Request {\n  const [method, path] = endpoint.split(' ');\n\n  const headers = new Headers(\n    Object.entries({\n      ...defaults?.headers,\n      ...input.headers,\n    }).filter(truthyEntry),\n  );\n  const pathVariable = template(path, input.params);\n\n  const url = createUrl(defaults.baseUrl, pathVariable, input.query);\n  return new Request(url, {\n    method: method,\n    headers: headers,\n    body: method === 'GET' ? undefined : input.body,\n  });\n}\n\nfunction truthyEntry(entry: [string, unknown]): entry is [string, string] {\n  return entry[1] !== undefined;\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";
 
 // packages/typescript/src/lib/http/send-request.txt
-var send_request_default = "import z from 'zod';\n\nimport { handleError, parseResponse } from './parse-response.ts';\nimport { parse } from './parser.ts';\n\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (\n    input: any,\n    init: { baseUrl: string; headers?: Partial<Record<string, string>> },\n  ) => any;\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: any,\n  route: RequestSchema,\n  options: {\n    baseUrl: string;\n    fetch?: z.infer<typeof fetchType>;\n    headers?: Partial<Record<string, string>>;\n  },\n) {\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  const request = route.toRequest(parsedInput as never, {\n    headers: options.headers,\n    baseUrl: options.baseUrl,\n  });\n  const response = await (options.fetch ?? fetch)(request);\n  if (response.ok) {\n    const data = await parseResponse(response);\n    return [data, 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 = "import z from 'zod';\n\nimport { handleError, parseResponse } from './parse-response.ts';\nimport { parse } from './parser.ts';\n\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (\n    input: any,\n    init: { baseUrl: string; headers?: Partial<Record<string, string>> },\n  ) => any;\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: any,\n  route: RequestSchema,\n  options: {\n    baseUrl: string;\n    fetch?: z.infer<typeof fetchType>;\n    headers?: Partial<Record<string, string>>;\n  },\n) {\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  const request = route.toRequest(parsedInput as never, {\n    headers: options.headers,\n    baseUrl: options.baseUrl,\n  });\n  const response = await (options.fetch ?? fetch)(request);\n  if (response.ok) {\n    const data = await parseResponse(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";
 
 // packages/typescript/src/lib/generate.ts
 function security(spec) {
@@ -928,22 +1091,35 @@ async function generate(spec, settings) {
     "request.ts": request_default
   });
   await writeFiles(join(output, "outputs"), outputs);
+  const imports = Object.entries(commonSchemas).map(([name]) => name);
   await writeFiles(output, {
     ...clientFiles,
-    "zod.ts": `import z from 'zod';
-${Object.entries(commonSchemas).map(([name, schema]) => `export const ${name} = ${schema};`).join("\n")}`
+    ...Object.fromEntries(
+      Object.entries(commonSchemas).map(([name, schema]) => [
+        `models/${name}.ts`,
+        [
+          `import { z } from 'zod';`,
+          ...exclude(imports, [name]).map(
+            (it) => `import type { ${it} } from './${it}.ts';`
+          ),
+          `export type ${name} = ${schema};`
+        ].join("\n")
+      ])
+    )
   });
-  const [index, outputIndex, inputsIndex, httpIndex] = await Promise.all([
+  const [index, outputIndex, inputsIndex, httpIndex, modelsIndex] = await Promise.all([
     getFolderExports(output),
     getFolderExports(join(output, "outputs")),
     getFolderExports(join(output, "inputs")),
-    getFolderExports(join(output, "http"))
+    getFolderExports(join(output, "http")),
+    getFolderExports(join(output, "models"))
   ]);
   await writeFiles(output, {
     "index.ts": index,
     "outputs/index.ts": outputIndex,
     "inputs/index.ts": inputsIndex,
-    "http/index.ts": httpIndex
+    "http/index.ts": httpIndex,
+    "models/index.ts": modelsIndex
   });
   if (settings.mode === "full") {
     await writeFiles(settings.output, {
@@ -958,6 +1134,9 @@ ${Object.entries(commonSchemas).map(([name, schema]) => `export const ${name} =
     env: npmRunPathEnv()
   });
 }
+function exclude(list, exclude2) {
+  return list.filter((it) => !exclude2.includes(it));
+}
 
 // packages/typescript/src/lib/watcher.ts
 import { watch as nodeWatch } from "node:fs/promises";