@sdk-it/typescript 0.6.0 → 0.8.0

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";
@@ -506,7 +256,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 +279,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 +321,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 +340,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 = {};
@@ -622,6 +390,418 @@ function securityToOptions(security2, securitySchemas, staticIn) {
   return options;
 }
 
+// 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 = {
   "400": "BadRequest",
@@ -653,6 +833,30 @@ var defaults = {
   }
 };
 function generateCode(config) {
+  const imports = [];
+  const zodDeserialzer = new ZodDeserialzer(config.spec, (schemaName, zod) => {
+    commonSchemas[schemaName] = zod;
+    imports.push({
+      defaultImport: void 0,
+      isTypeOnly: false,
+      moduleSpecifier: `../models/${schemaName}.ts`,
+      namedImports: [{ isTypeOnly: false, name: schemaName }],
+      namespaceImport: void 0
+    });
+  });
+  const typeScriptDeserialzer = new TypeScriptDeserialzer(
+    config.spec,
+    (schemaName, zod) => {
+      commonSchemas[schemaName] = zod;
+      imports.push({
+        defaultImport: void 0,
+        isTypeOnly: true,
+        moduleSpecifier: `../models/${schemaName}.ts`,
+        namedImports: [{ isTypeOnly: true, name: schemaName }],
+        namespaceImport: void 0
+      });
+    }
+  );
   const groups = {};
   const commonSchemas = {};
   const outputs = {};
@@ -664,7 +868,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)) {
@@ -708,8 +911,7 @@ function generateCode(config) {
         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,
+          types[shortContenTypeMap[type]] = zodDeserialzer.handle(
             merge(schema, {
               required: additionalProperties.filter((p) => p.required).map((p) => p.name),
               properties: additionalProperties.reduce(
@@ -720,17 +922,7 @@ function generateCode(config) {
                 {}
               )
             }),
-            true,
-            (schemaName, zod) => {
-              commonSchemas[schemaName] = zod;
-              imports.push({
-                defaultImport: void 0,
-                isTypeOnly: false,
-                moduleSpecifier: "../zod",
-                namedImports: [{ isTypeOnly: false, name: schemaName }],
-                namespaceImport: void 0
-              });
-            }
+            true
           );
         }
         if (content["application/json"]) {
@@ -743,30 +935,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,34 +965,23 @@ function generateCode(config) {
           foundResponse = true;
           const responseContent = get2(response, ["content"]);
           const isJson = responseContent && responseContent["application/json"];
-          const responseSchema = isJson ? jsonSchemaToZod(
-            config.spec,
+          const responseSchema = isJson ? typeScriptDeserialzer.handle(
             responseContent["application/json"].schema,
-            true,
-            (schemaName, zod) => {
-              commonSchemas[schemaName] = zod;
-              imports.push({
-                defaultImport: void 0,
-                isTypeOnly: false,
-                moduleSpecifier: "../zod",
-                namedImports: [{ isTypeOnly: false, name: schemaName }],
-                namespaceImport: void 0
-              });
-            }
-          ) : "z.instanceof(ReadableStream)";
+            true
+          ) : "ReadableStream";
           output.push(
             importsToString(mergeImports(Object.values(imports).flat())).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");
@@ -824,7 +995,7 @@ function generateCode(config) {
         schemas: types,
         formatOutput: () => ({
           import: pascalcase2(operationName + " output"),
-          use: `z.infer<typeof ${pascalcase2(operationName + " output")}>`
+          use: pascalcase2(operationName + " output")
         }),
         trigger: {
           path,
@@ -851,17 +1022,17 @@ function mergeImports(imports) {
   return Object.values(merged);
 }
 function importsToString(imports) {
-  return imports.map((i) => {
-    if (i.defaultImport) {
-      return `import ${i.defaultImport} from '${i.moduleSpecifier}'`;
+  return imports.map((it) => {
+    if (it.defaultImport) {
+      return `import ${it.defaultImport} from '${it.moduleSpecifier}'`;
     }
-    if (i.namespaceImport) {
-      return `import * as ${i.namespaceImport} from '${i.moduleSpecifier}'`;
+    if (it.namespaceImport) {
+      return `import * as ${it.namespaceImport} from '${it.moduleSpecifier}'`;
     }
-    if (i.namedImports) {
-      return `import {${removeDuplicates(i.namedImports, (it) => it.name).map((n) => n.name).join(", ")}} from '${i.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(i)}`);
+    throw new Error(`Invalid import ${JSON.stringify(it)}`);
   });
 }
 
@@ -907,6 +1078,7 @@ async function generate(spec, settings) {
     style: "github",
     target: "javascript"
   });
+  const output = settings.mode === "full" ? join(settings.output, "src") : settings.output;
   const options = security(spec);
   const clientFiles = generateClientSdk({
     name: settings.name || "Client",
@@ -914,41 +1086,65 @@ async function generate(spec, settings) {
     servers: spec.servers?.map((server) => server.url) || [],
     options
   });
-  await writeFiles(settings.output, {
+  await writeFiles(output, {
     "outputs/index.ts": "",
     "inputs/index.ts": ""
     // 'README.md': readme,
   });
-  await writeFiles(join(settings.output, "http"), {
+  await writeFiles(join(output, "http"), {
     "parse-response.ts": client_default2,
     "send-request.ts": send_request_default,
     "response.ts": response_default,
     "parser.ts": parser_default,
     "request.ts": request_default
   });
-  await writeFiles(join(settings.output, "outputs"), outputs);
-  await writeFiles(settings.output, {
+  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([
-    getFolderExports(settings.output),
-    getFolderExports(join(settings.output, "outputs")),
-    getFolderExports(join(settings.output, "inputs")),
-    getFolderExports(join(settings.output, "http"))
+  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, "models"))
   ]);
-  await writeFiles(settings.output, {
+  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, {
+      "package.json": {
+        ignoreIfExists: true,
+        content: `{"type":"module","main":"./src/index.ts","dependencies":{"fast-content-type-parse":"^2.0.1"}}`
+      }
+    });
+  }
   await settings.formatCode?.({
-    output: settings.output,
+    output,
     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";