@sdk-it/typescript 0.22.1 → 0.24.0

package/dist/index.js

@@ -15,24 +15,295 @@ import {
   augmentSpec,
   cleanFiles,
   readWriteMetadata,
-  sanitizeTag as sanitizeTag4
+  sanitizeTag as sanitizeTag4,
+  securityToOptions as securityToOptions2
 } from "@sdk-it/spec";
 
 // packages/typescript/src/lib/client.ts
 import { toLitObject } from "@sdk-it/core";
+
+// packages/typescript/src/lib/emitters/zod.ts
+import { followRef, isRef, parseRef, pascalcase } from "@sdk-it/core";
+import { isPrimitiveSchema, sanitizeTag } from "@sdk-it/spec";
+var ZodEmitter = class {
+  #generatedRefs = /* @__PURE__ */ new Set();
+  #spec;
+  #onRef;
+  constructor(spec, onRef) {
+    this.#spec = spec;
+    this.#onRef = onRef;
+  }
+  #object(schema) {
+    const properties = schema.properties || {};
+    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
+      const isRequired = (schema.required ?? []).includes(key);
+      return `'${key}': ${this.handle(propSchema, isRequired)}`;
+    });
+    let additionalProps = "";
+    if (schema.additionalProperties) {
+      if (typeof schema.additionalProperties === "object") {
+        const addPropZod = this.handle(schema.additionalProperties, true);
+        additionalProps = `.catchall(${addPropZod})`;
+      } else if (schema.additionalProperties === true) {
+        additionalProps = `.catchall(z.unknown())`;
+      }
+    }
+    return `z.object({${propEntries.join(", ")}})${additionalProps}`;
+  }
+  #array(schema, required = false) {
+    const { items } = schema;
+    if (!items) {
+      return `z.array(z.unknown())${appendOptional(required)}`;
+    }
+    if (Array.isArray(items)) {
+      const tupleItems = items.map((sub) => this.handle(sub, true));
+      const base = `z.tuple([${tupleItems.join(", ")}])`;
+      return `${base}${appendOptional(required)}`;
+    }
+    const itemsSchema = this.handle(items, true);
+    return `z.array(${itemsSchema})${this.#suffixes(JSON.stringify(schema.default), required, false)}`;
+  }
+  #suffixes = (defaultValue, required, nullable) => {
+    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional(required)}`;
+  };
+  /**
+   * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
+   * We'll also handle .optional() if needed.
+   */
+  normal(type, schema, required = false, nullable = false) {
+    switch (type) {
+      case "string":
+        return `${this.string(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
+      case "number":
+      case "integer": {
+        const { base, defaultValue } = this.#number(schema);
+        return `${base}${this.#suffixes(defaultValue, required, nullable)}`;
+      }
+      case "boolean":
+        return `z.boolean()${this.#suffixes(schema.default, required, nullable)}`;
+      case "object":
+        return `${this.#object(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
+      // required always
+      case "array":
+        return this.#array(schema, required);
+      case "null":
+        return `z.null()${appendOptional(required)}`;
+      default:
+        return `z.unknown()${appendOptional(required)}`;
+    }
+  }
+  #ref($ref, required) {
+    const schemaName = pascalcase(sanitizeTag(parseRef($ref).model));
+    const schema = followRef(this.#spec, $ref);
+    if (isPrimitiveSchema(schema)) {
+      const result = this.handle(schema, required);
+      this.#onRef?.(schemaName, result);
+      return result;
+    }
+    if (this.#generatedRefs.has(schemaName)) {
+      return schemaName;
+    }
+    this.#generatedRefs.add(schemaName);
+    this.#onRef?.(schemaName, this.handle(schema, required));
+    return schemaName;
+  }
+  #toIntersection(schemas) {
+    const [left, ...right] = schemas;
+    if (!right.length) {
+      return left;
+    }
+    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
+  }
+  allOf(schemas, required) {
+    const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (allOfSchemas.length === 0) {
+      return `z.unknown()`;
+    }
+    if (allOfSchemas.length === 1) {
+      return `${allOfSchemas[0]}${appendOptional(required)}`;
+    }
+    return `${this.#toIntersection(allOfSchemas)}${appendOptional(required)}`;
+  }
+  anyOf(schemas, required) {
+    const anyOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (anyOfSchemas.length === 1) {
+      return `${anyOfSchemas[0]}${appendOptional(required)}`;
+    }
+    return `z.union([${anyOfSchemas.join(", ")}])${appendOptional(required)}`;
+  }
+  oneOf(schemas, required) {
+    const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (oneOfSchemas.length === 1) {
+      return `${oneOfSchemas[0]}${appendOptional(required)}`;
+    }
+    return `z.union([${oneOfSchemas.join(", ")}])${appendOptional(required)}`;
+  }
+  enum(type, values) {
+    if (values.length === 1) {
+      return `z.literal(${values.join(", ")})`;
+    }
+    if (type === "integer") {
+      return `z.union([${values.map((val) => `z.literal(${val})`).join(", ")}])`;
+    }
+    return `z.enum([${values.join(", ")}])`;
+  }
+  /**
+   * Handle a `string` schema with possible format keywords (JSON Schema).
+   */
+  string(schema) {
+    let base = "z.string()";
+    if (schema.contentEncoding === "binary") {
+      base = "z.instanceof(Blob)";
+      return base;
+    }
+    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)";
+        break;
+      case "int64":
+        base = "z.string() /* or z.bigint() if your app can handle it */";
+        break;
+      default:
+        break;
+    }
+    return base;
+  }
+  /**
+   * Handle number/integer constraints from OpenAPI/JSON Schema.
+   * In 3.1, exclusiveMinimum/Maximum hold the actual numeric threshold,
+   * rather than a boolean toggling `minimum`/`maximum`.
+   */
+  #number(schema) {
+    let defaultValue = schema.default;
+    let base = "z.number()";
+    if (schema.format === "int64") {
+      base = "z.bigint()";
+      if (schema.default !== void 0) {
+        defaultValue = `BigInt(${schema.default})`;
+      }
+    }
+    if (schema.format === "int32") {
+      base += ".int()";
+    }
+    if (typeof schema.exclusiveMinimum === "number") {
+      base += `.gt(${schema.exclusiveMinimum})`;
+    }
+    if (typeof schema.exclusiveMaximum === "number") {
+      base += `.lt(${schema.exclusiveMaximum})`;
+    }
+    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 };
+  }
+  handle(schema, required) {
+    if (isRef(schema)) {
+      return `${this.#ref(schema.$ref, true)}${appendOptional(required)}`;
+    }
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      return this.allOf(schema.allOf ?? [], required);
+    }
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      return this.anyOf(schema.anyOf ?? [], required);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length) {
+      return this.oneOf(schema.oneOf ?? [], required);
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      const enumVals = schema.enum.map((val) => JSON.stringify(val));
+      const defaultValue = enumVals.includes(JSON.stringify(schema.default)) ? JSON.stringify(schema.default) : void 0;
+      return `${this.enum(schema.type, enumVals)}${this.#suffixes(defaultValue, required, false)}`;
+    }
+    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    if (!types.length) {
+      return `z.unknown()${appendOptional(required)}`;
+    }
+    if ("nullable" in schema && schema.nullable) {
+      types.push("null");
+    } else if (schema.default === null) {
+      types.push("null");
+    }
+    if (types.length > 1) {
+      const realTypes = types.filter((t) => t !== "null");
+      if (realTypes.length === 1 && types.includes("null")) {
+        return this.normal(realTypes[0], schema, required, true);
+      }
+      const subSchemas = types.map((t) => this.normal(t, schema, false));
+      return `z.union([${subSchemas.join(", ")}])${appendOptional(required)}`;
+    }
+    return this.normal(types[0], schema, required, false);
+  }
+};
+function appendOptional(isRequired) {
+  return isRequired ? "" : ".optional()";
+}
+function appendDefault(defaultValue) {
+  return defaultValue !== void 0 || typeof defaultValue !== "undefined" ? `.default(${defaultValue})` : "";
+}
+function toZod(schema, required) {
+  const emitter = new ZodEmitter({});
+  const schemaStr = emitter.handle(schema, required ?? false);
+  if (schema["x-prefix"]) {
+    const prefix = schema["x-prefix"];
+    if (required === false) {
+      return schemaStr + `.transform((val) => (val ? \`${prefix}\${val}\` : undefined))`;
+    } else {
+      return schemaStr + `.transform((val) => \`${prefix}\${val}\`)`;
+    }
+  }
+  return schemaStr;
+}
+
+// packages/typescript/src/lib/client.ts
 var client_default = (spec, style) => {
-  const optionsEntries = Object.entries(spec.options).map(
-    ([key, value]) => [`'${key}'`, value]
-  );
-  const defaultHeaders = `{${optionsEntries.filter(([, value]) => value.in === "header").map(
-    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
+  const defaultHeaders = `{${spec.options.filter((value) => value.in === "header").map(
+    (value) => `'${value.name}': this.options['${value["x-optionName"] ?? value.name}']`
   ).join(",\n")}}`;
-  const defaultInputs = `{${optionsEntries.filter(([, value]) => value.in === "input").map(
-    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
+  const defaultInputs = `{${spec.options.filter((value) => value.in === "input").map(
+    (value) => `'${value.name}': this.options['${value["x-optionName"] ?? value.name}']`
   ).join(",\n")}}`;
   const specOptions = {
     ...Object.fromEntries(
-      optionsEntries.map(([key, value]) => [value.optionName ?? key, value])
+      spec.options.map((value) => [
+        `'${value["x-optionName"] ?? value.name}'`,
+        { schema: toZod(value.schema, value.required) }
+      ])
     ),
     fetch: {
       schema: "fetchType"
@@ -145,8 +416,8 @@ export class ${spec.name} {
 };
 
 // packages/typescript/src/lib/emitters/interface.ts
-import { followRef, isRef, parseRef, pascalcase } from "@sdk-it/core";
-import { isPrimitiveSchema, sanitizeTag } from "@sdk-it/spec";
+import { followRef as followRef2, isRef as isRef2, parseRef as parseRef2, pascalcase as pascalcase2 } from "@sdk-it/core";
+import { isPrimitiveSchema as isPrimitiveSchema2, sanitizeTag as sanitizeTag2 } from "@sdk-it/spec";
 var TypeScriptEmitter = class {
   #spec;
   constructor(spec) {
@@ -198,381 +469,160 @@ var TypeScriptEmitter = class {
       case "integer":
         return this.number(schema, required);
       case "boolean":
-        return appendOptional("boolean", required);
+        return appendOptional2("boolean", required);
       case "object":
         return this.object(schema, required);
       case "array":
-        return this.#array(schema, required);
-      case "null":
-        return "null";
-      default:
-        console.warn(`Unknown type: ${type}`);
-        return appendOptional("any", required);
-    }
-  }
-  #ref($ref, required) {
-    const schemaName = pascalcase(sanitizeTag(parseRef($ref).model));
-    const schema = followRef(this.#spec, $ref);
-    if (isPrimitiveSchema(schema)) {
-      return this.handle(schema, required);
-    }
-    return `models.${appendOptional(schemaName, required)}`;
-  }
-  allOf(schemas) {
-    const allOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return allOfTypes.length > 1 ? `${allOfTypes.join(" & ")}` : allOfTypes[0];
-  }
-  oneOf(schemas, required) {
-    const oneOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return appendOptional(
-      oneOfTypes.length > 1 ? `${oneOfTypes.join(" | ")}` : oneOfTypes[0],
-      required
-    );
-  }
-  anyOf(schemas, required) {
-    return this.oneOf(schemas, 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;
-    if (schema.contentEncoding === "binary") {
-      return appendOptional("Blob", required);
-    }
-    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);
-    }
-    if (schema.const) {
-      return this.enum([schema.const], true);
-    }
-    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-    if (!types.length) {
-      if ("properties" in schema) {
-        return this.object(schema, required);
-      }
-      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);
-  }
-};
-function appendOptional(type, isRequired) {
-  return isRequired ? type : `${type} | undefined`;
-}
-
-// packages/typescript/src/lib/generator.ts
-import { merge, template } from "lodash-es";
-import { join } from "node:path";
-import { camelcase as camelcase2, spinalcase } from "stringcase";
-import { followRef as followRef4, isEmpty as isEmpty2, isRef as isRef4, resolveRef } from "@sdk-it/core";
-import { forEachOperation } from "@sdk-it/spec";
-
-// packages/typescript/src/lib/emitters/zod.ts
-import { followRef as followRef2, isRef as isRef2, parseRef as parseRef2, pascalcase as pascalcase2 } from "@sdk-it/core";
-import { isPrimitiveSchema as isPrimitiveSchema2, sanitizeTag as sanitizeTag2 } from "@sdk-it/spec";
-var ZodEmitter = class {
-  #generatedRefs = /* @__PURE__ */ new Set();
-  #spec;
-  #onRef;
-  constructor(spec, onRef) {
-    this.#spec = spec;
-    this.#onRef = onRef;
-  }
-  /**
-   * Handle objects (properties, additionalProperties).
-   */
-  object(schema) {
-    const properties = schema.properties || {};
-    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
-      const isRequired = (schema.required ?? []).includes(key);
-      return `'${key}': ${this.handle(propSchema, isRequired)}`;
-    });
-    let additionalProps = "";
-    if (schema.additionalProperties) {
-      if (typeof schema.additionalProperties === "object") {
-        const addPropZod = this.handle(schema.additionalProperties, true);
-        additionalProps = `.catchall(${addPropZod})`;
-      } else if (schema.additionalProperties === true) {
-        additionalProps = `.catchall(z.unknown())`;
-      }
-    }
-    return `z.object({${propEntries.join(", ")}})${additionalProps}`;
-  }
-  #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})${this.#suffixes(JSON.stringify(schema.default), required, false)}`;
-  }
-  #suffixes = (defaultValue, required, nullable) => {
-    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional2(required)}`;
-  };
-  /**
-   * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
-   * We'll also handle .optional() if needed.
-   */
-  normal(type, schema, required = false, nullable = false) {
-    switch (type) {
-      case "string":
-        return `${this.string(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
-      case "number":
-      case "integer": {
-        const { base, defaultValue } = this.number(schema);
-        return `${base}${this.#suffixes(defaultValue, required, nullable)}`;
-      }
-      case "boolean":
-        return `z.boolean()${this.#suffixes(schema.default, required, nullable)}`;
-      case "object":
-        return `${this.object(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
-      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 = pascalcase2(sanitizeTag2(parseRef2($ref).model));
-    const schema = followRef2(this.#spec, $ref);
-    if (isPrimitiveSchema2(schema)) {
-      const result = this.handle(schema, required);
-      this.#onRef?.(schemaName, result);
-      return result;
-    }
-    if (this.#generatedRefs.has(schemaName)) {
-      return schemaName;
-    }
-    this.#generatedRefs.add(schemaName);
-    this.#onRef?.(schemaName, this.handle(schema, required));
-    return schemaName;
-  }
-  #toIntersection(schemas) {
-    const [left, ...right] = schemas;
-    if (!right.length) {
-      return left;
-    }
-    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
-  }
-  allOf(schemas, required) {
-    const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
-    if (allOfSchemas.length === 0) {
-      return `z.unknown()`;
-    }
-    if (allOfSchemas.length === 1) {
-      return `${allOfSchemas[0]}${appendOptional2(required)}`;
+        return this.#array(schema, required);
+      case "null":
+        return "null";
+      default:
+        console.warn(`Unknown type: ${type}`);
+        return appendOptional2("any", required);
     }
-    return `${this.#toIntersection(allOfSchemas)}${appendOptional2(required)}`;
   }
-  anyOf(schemas, required) {
-    const anyOfSchemas = schemas.map((sub) => this.handle(sub, true));
-    if (anyOfSchemas.length === 1) {
-      return `${anyOfSchemas[0]}${appendOptional2(required)}`;
+  #ref($ref, required) {
+    const schemaName = pascalcase2(sanitizeTag2(parseRef2($ref).model));
+    const schema = followRef2(this.#spec, $ref);
+    if (isPrimitiveSchema2(schema)) {
+      return this.handle(schema, required);
     }
-    return `z.union([${anyOfSchemas.join(", ")}])${appendOptional2(required)}`;
+    return `models.${appendOptional2(schemaName, required)}`;
+  }
+  allOf(schemas) {
+    const allOfTypes = schemas.map((sub) => this.handle(sub, true));
+    return allOfTypes.length > 1 ? `${allOfTypes.join(" & ")}` : allOfTypes[0];
   }
   oneOf(schemas, required) {
-    const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
-    if (oneOfSchemas.length === 1) {
-      return `${oneOfSchemas[0]}${appendOptional2(required)}`;
-    }
-    return `z.union([${oneOfSchemas.join(", ")}])${appendOptional2(required)}`;
+    const oneOfTypes = schemas.map((sub) => this.handle(sub, true));
+    return appendOptional2(
+      oneOfTypes.length > 1 ? `${oneOfTypes.join(" | ")}` : oneOfTypes[0],
+      required
+    );
   }
-  enum(type, values) {
-    if (values.length === 1) {
-      return `z.literal(${values.join(", ")})`;
-    }
-    if (type === "integer") {
-      return `z.union([${values.map((val) => `z.literal(${val})`).join(", ")}])`;
-    }
-    return `z.enum([${values.join(", ")}])`;
+  anyOf(schemas, required) {
+    return this.oneOf(schemas, required);
+  }
+  enum(values, required) {
+    const enumValues = values.map((val) => typeof val === "string" ? `'${val}'` : `${val}`).join(" | ");
+    return appendOptional2(enumValues, required);
   }
   /**
-   * Handle a `string` schema with possible format keywords (JSON Schema).
+   * Handle string type with formats
    */
-  string(schema) {
-    let base = "z.string()";
+  string(schema, required) {
+    let type;
     if (schema.contentEncoding === "binary") {
-      base = "z.instanceof(Blob)";
-      return base;
+      return appendOptional2("Blob", required);
     }
     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 */";
+        type = "Date";
         break;
-      case "byte":
       case "binary":
-        base = "z.instanceof(Blob)";
+      case "byte":
+        type = "Blob";
         break;
       case "int64":
-        base = "z.string() /* or z.bigint() if your app can handle it */";
+        type = "bigint";
         break;
       default:
-        break;
+        type = "string";
     }
-    return base;
+    return appendOptional2(type, 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`.
+   * Handle number/integer types with formats
    */
-  number(schema) {
-    let defaultValue = schema.default;
-    let base = "z.number()";
-    if (schema.format === "int64") {
-      base = "z.bigint()";
-      if (schema.default !== void 0) {
-        defaultValue = `BigInt(${schema.default})`;
-      }
-    }
-    if (schema.format === "int32") {
-      base += ".int()";
-    }
-    if (typeof schema.exclusiveMinimum === "number") {
-      base += `.gt(${schema.exclusiveMinimum})`;
-    }
-    if (typeof schema.exclusiveMaximum === "number") {
-      base += `.lt(${schema.exclusiveMaximum})`;
-    }
-    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 };
+  number(schema, required) {
+    const type = schema.format === "int64" ? "bigint" : "number";
+    return appendOptional2(type, required);
   }
   handle(schema, required) {
     if (isRef2(schema)) {
-      return `${this.#ref(schema.$ref, true)}${appendOptional2(required)}`;
+      return this.#ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
-      return this.allOf(schema.allOf ?? [], required);
+      return this.allOf(schema.allOf);
     }
     if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.anyOf(schema.anyOf ?? [], required);
+      return this.anyOf(schema.anyOf, required);
     }
-    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length) {
-      return this.oneOf(schema.oneOf ?? [], required);
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.oneOf(schema.oneOf, required);
     }
     if (schema.enum && Array.isArray(schema.enum)) {
-      const enumVals = schema.enum.map((val) => JSON.stringify(val));
-      const defaultValue = enumVals.includes(JSON.stringify(schema.default)) ? JSON.stringify(schema.default) : void 0;
-      return `${this.enum(schema.type, enumVals)}${this.#suffixes(defaultValue, required, false)}`;
+      return this.enum(schema.enum, required);
+    }
+    if (schema.const) {
+      return this.enum([schema.const], true);
     }
     const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
     if (!types.length) {
-      return `z.unknown()${appendOptional2(required)}`;
-    }
-    if ("nullable" in schema && schema.nullable) {
-      types.push("null");
-    } else if (schema.default === null) {
-      types.push("null");
+      if ("properties" in schema) {
+        return this.object(schema, required);
+      }
+      return appendOptional2("any", required);
     }
     if (types.length > 1) {
       const realTypes = types.filter((t) => t !== "null");
       if (realTypes.length === 1 && types.includes("null")) {
-        return this.normal(realTypes[0], schema, required, true);
+        const tsType = this.normal(realTypes[0], schema, false);
+        return appendOptional2(`${tsType} | null`, required);
       }
-      const subSchemas = types.map((t) => this.normal(t, schema, false));
-      return `z.union([${subSchemas.join(", ")}])${appendOptional2(required)}`;
+      const typeResults = types.map((t) => this.normal(t, schema, false));
+      return appendOptional2(typeResults.join(" | "), required);
     }
-    return this.normal(types[0], schema, required, false);
+    return this.normal(types[0], schema, required);
   }
 };
-function appendOptional2(isRequired) {
-  return isRequired ? "" : ".optional()";
+function appendOptional2(type, isRequired) {
+  return isRequired ? type : `${type} | undefined`;
 }
-function appendDefault(defaultValue) {
-  return defaultValue !== void 0 || typeof defaultValue !== "undefined" ? `.default(${defaultValue})` : "";
+
+// packages/typescript/src/lib/generator.ts
+import { merge, template } from "lodash-es";
+import { join } from "node:path";
+import { camelcase as camelcase2, spinalcase } from "stringcase";
+import { followRef as followRef3, isEmpty as isEmpty2, isRef as isRef3, resolveRef } from "@sdk-it/core";
+import { forEachOperation } from "@sdk-it/spec";
+
+// packages/typescript/src/lib/import-utilities.ts
+import { removeDuplicates } from "@sdk-it/core";
+function mergeImports(...imports) {
+  const merged = {};
+  for (const it of imports) {
+    merged[it.moduleSpecifier] = merged[it.moduleSpecifier] ?? {
+      moduleSpecifier: it.moduleSpecifier,
+      defaultImport: it.defaultImport,
+      namespaceImport: it.namespaceImport,
+      namedImports: []
+    };
+    for (const named of it.namedImports) {
+      if (!merged[it.moduleSpecifier].namedImports.some(
+        (x) => x.name === named.name
+      )) {
+        merged[it.moduleSpecifier].namedImports.push(named);
+      }
+    }
+  }
+  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/sdk.ts
@@ -613,75 +663,6 @@ var status_map_default = {
   "504": "GatewayTimeout"
 };
 
-// packages/typescript/src/lib/utils.ts
-import { followRef as followRef3, isRef as isRef3, removeDuplicates } from "@sdk-it/core";
-function securityToOptions(spec, security2, securitySchemes, staticIn) {
-  securitySchemes ??= {};
-  const options = {};
-  for (const it of security2) {
-    const [name] = Object.keys(it);
-    if (!name) {
-      continue;
-    }
-    const schema = isRef3(securitySchemes[name]) ? followRef3(spec, securitySchemes[name].$ref) : securitySchemes[name];
-    if (schema.type === "http") {
-      options["authorization"] = {
-        in: staticIn ?? "header",
-        schema: "z.string().optional().transform((val) => (val ? `Bearer ${val}` : undefined))",
-        optionName: "token"
-      };
-      continue;
-    }
-    if (schema.type === "apiKey") {
-      if (!schema.in) {
-        throw new Error(`apiKey security schema must have an "in" field`);
-      }
-      if (!schema.name) {
-        throw new Error(`apiKey security schema must have a "name" field`);
-      }
-      options[schema.name] = {
-        in: staticIn ?? schema.in,
-        schema: "z.string().optional()"
-      };
-      continue;
-    }
-  }
-  return options;
-}
-function mergeImports(...imports) {
-  const merged = {};
-  for (const it of imports) {
-    merged[it.moduleSpecifier] = merged[it.moduleSpecifier] ?? {
-      moduleSpecifier: it.moduleSpecifier,
-      defaultImport: it.defaultImport,
-      namespaceImport: it.namespaceImport,
-      namedImports: []
-    };
-    for (const named of it.namedImports) {
-      if (!merged[it.moduleSpecifier].namedImports.some(
-        (x) => x.name === named.name
-      )) {
-        merged[it.moduleSpecifier].namedImports.push(named);
-      }
-    }
-  }
-  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/sdk.ts
 function toEndpoint(groupName, spec, specOperation, operation, utils) {
   const schemaName = camelcase(`${operation.name} schema`);
@@ -953,36 +934,6 @@ function generateCode(config) {
     groups[entry.groupName] ??= [];
     endpoints[entry.groupName] ??= [];
     const inputs = {};
-    const additionalProperties = {};
-    for (const param of operation.parameters) {
-      if (!param.schema) {
-        param.schema = {
-          type: "string"
-        };
-      }
-      inputs[param.name] = {
-        in: param.in,
-        schema: ""
-      };
-      additionalProperties[param.name] = param;
-    }
-    const securitySchemes = config.spec.components?.securitySchemes ?? {};
-    const securityOptions = securityToOptions(
-      config.spec,
-      operation.security ?? [],
-      securitySchemes
-    );
-    Object.assign(inputs, securityOptions);
-    Object.entries(securityOptions).forEach(([name, value]) => {
-      additionalProperties[name] = {
-        name,
-        required: false,
-        schema: {
-          type: "string"
-        },
-        in: value.in
-      };
-    });
     const schemas = {};
     const shortContenTypeMap = {
       "application/json": "json",
@@ -1001,11 +952,12 @@ function generateCode(config) {
         config.spec,
         operation.requestBody.content[type].schema
       );
+      const xProperties = objectSchema["x-properties"] ?? {};
+      const xRequired = objectSchema["x-required"] ?? [];
       if (type === "application/empty") {
         objectSchema = {
           type: "object",
-          // properties: objectSchema['x-properties'],
-          additionalProperties: isEmpty2(objectSchema["x-properties"])
+          additionalProperties: isEmpty2(xProperties)
         };
       } else {
         if (objectSchema.type !== "object") {
@@ -1014,14 +966,29 @@ function generateCode(config) {
             required: [operation.requestBody.required ? "$body" : ""],
             properties: {
               $body: objectSchema
-              // ...objectSchema['x-properties'],
             }
           };
         }
       }
+      const additionalProperties = {};
+      for (const [name, prop] of Object.entries(xProperties)) {
+        additionalProperties[name] = {
+          name,
+          required: xRequired?.includes(name),
+          schema: prop,
+          in: prop["x-in"]
+        };
+        inputs[name] = {
+          in: prop["x-in"],
+          schema: ""
+        };
+      }
       const schema = merge({}, objectSchema, {
         required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
-        properties: Object.entries(additionalProperties).reduce((acc, [, p]) => ({ ...acc, [p.name]: p.schema }), {})
+        properties: Object.entries(additionalProperties).reduce(
+          (acc, [, p]) => ({ ...acc, [p.name]: p.schema }),
+          {}
+        )
       });
       Object.assign(inputs, bodyInputs(config.spec, objectSchema));
       schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
@@ -1123,8 +1090,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef4(schemaOrRef)) {
-    const schema = followRef4(spec, schemaOrRef.$ref);
+  if (isRef3(schemaOrRef)) {
+    const schema = followRef3(spec, schemaOrRef.$ref);
     return toProps(spec, schema, aggregator);
   } else if (schemaOrRef.type === "object") {
     for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
@@ -1632,11 +1599,11 @@ import { camelcase as camelcase3, spinalcase as spinalcase2 } from "stringcase";
 import { isEmpty as isEmpty3, pascalcase as pascalcase4, resolveRef as resolveRef2 } from "@sdk-it/core";
 import {
   patchParameters,
-  securityToOptions as securityToOptions2
+  securityToOptions
 } from "@sdk-it/spec";
 
 // packages/typescript/src/lib/emitters/snippet.ts
-import { followRef as followRef5, isRef as isRef5 } from "@sdk-it/core";
+import { followRef as followRef4, isRef as isRef4 } from "@sdk-it/core";
 var SnippetEmitter = class {
   spec;
   generatedRefs = /* @__PURE__ */ new Set();
@@ -1645,12 +1612,12 @@ var SnippetEmitter = class {
     this.spec = spec;
   }
   object(schema) {
-    const schemaObj = isRef5(schema) ? followRef5(this.spec, schema.$ref) : schema;
+    const schemaObj = isRef4(schema) ? followRef4(this.spec, schema.$ref) : schema;
     const result = {};
     const properties = schemaObj.properties || {};
     for (const [propName, propSchema] of Object.entries(properties)) {
       const isRequired = (schemaObj.required ?? []).includes(propName);
-      const resolvedProp = isRef5(propSchema) ? followRef5(this.spec, propSchema.$ref) : propSchema;
+      const resolvedProp = isRef4(propSchema) ? followRef4(this.spec, propSchema.$ref) : propSchema;
       if (isRequired || resolvedProp.example !== void 0 || resolvedProp.default !== void 0 || Math.random() > 0.5) {
         result[propName] = this.handle(propSchema);
       }
@@ -1663,7 +1630,7 @@ var SnippetEmitter = class {
     return result;
   }
   array(schema) {
-    const schemaObj = isRef5(schema) ? followRef5(this.spec, schema.$ref) : schema;
+    const schemaObj = isRef4(schema) ? followRef4(this.spec, schema.$ref) : schema;
     const itemsSchema = schemaObj.items;
     if (!itemsSchema) {
       return [];
@@ -1676,10 +1643,8 @@ var SnippetEmitter = class {
     return result;
   }
   string(schema) {
-    if (schema.example !== void 0)
-      return String(schema.example);
-    if (schema.default !== void 0)
-      return String(schema.default);
+    if (schema.example !== void 0) return String(schema.example);
+    if (schema.default !== void 0) return String(schema.default);
     switch (schema.format) {
       case "date-time":
       case "datetime":
@@ -1712,10 +1677,8 @@ var SnippetEmitter = class {
     }
   }
   number(schema) {
-    if (schema.example !== void 0)
-      return Number(schema.example);
-    if (schema.default !== void 0)
-      return Number(schema.default);
+    if (schema.example !== void 0) return Number(schema.example);
+    if (schema.default !== void 0) return Number(schema.default);
     let value;
     if (typeof schema.exclusiveMinimum === "number") {
       value = schema.exclusiveMinimum + 1;
@@ -1735,10 +1698,8 @@ var SnippetEmitter = class {
     return schema.type === "integer" ? Math.floor(value) : value;
   }
   boolean(schema) {
-    if (schema.example !== void 0)
-      return Boolean(schema.example);
-    if (schema.default !== void 0)
-      return Boolean(schema.default);
+    if (schema.example !== void 0) return Boolean(schema.example);
+    if (schema.default !== void 0) return Boolean(schema.default);
     return true;
   }
   null() {
@@ -1751,7 +1712,7 @@ var SnippetEmitter = class {
       return this.cache.get($ref);
     }
     this.cache.set($ref, { _ref: refKey });
-    const resolved = followRef5(this.spec, $ref);
+    const resolved = followRef4(this.spec, $ref);
     const result = this.handle(resolved);
     this.cache.set($ref, result);
     return result;
@@ -1767,23 +1728,21 @@ var SnippetEmitter = class {
     }, initial);
   }
   anyOf(schemas) {
-    if (schemas.length === 0)
-      return {};
+    if (schemas.length === 0) return {};
     return this.handle(schemas[0]);
   }
   oneOf(schemas) {
-    if (schemas.length === 0)
-      return {};
+    if (schemas.length === 0) return {};
     return this.handle(schemas[0]);
   }
   enum(schema) {
     return Array.isArray(schema.enum) && schema.enum.length > 0 ? schema.enum[0] : void 0;
   }
   handle(schemaOrRef) {
-    if (isRef5(schemaOrRef)) {
+    if (isRef4(schemaOrRef)) {
       return this.ref(schemaOrRef.$ref);
     }
-    const schema = isRef5(schemaOrRef) ? followRef5(this.spec, schemaOrRef.$ref) : schemaOrRef;
+    const schema = isRef4(schemaOrRef) ? followRef4(this.spec, schemaOrRef.$ref) : schemaOrRef;
     if (schema.example !== void 0) {
       return schema.example;
     }
@@ -1981,7 +1940,7 @@ var TypeScriptGenerator = class {
     return content.join("\n");
   }
   #authentication() {
-    return securityToOptions2(
+    return securityToOptions(
       this.#spec,
       this.#spec.security ?? [],
       this.#spec.components?.securitySchemes ?? {}
@@ -1994,7 +1953,9 @@ var TypeScriptGenerator = class {
     const authOptions = this.#authentication();
     if (!isEmpty3(authOptions)) {
       const [firstAuth] = authOptions;
-      inputs.push(`${firstAuth.name}: ${firstAuth.example}`);
+      inputs.push(
+        `'${firstAuth["x-optionName"] ?? firstAuth.name}': ${firstAuth.example}`
+      );
     }
     return `import { ${this.#clientName} } from '${this.#packageName}';
 
@@ -2014,7 +1975,7 @@ function security(spec) {
   const components = spec.components || {};
   const securitySchemes = components.securitySchemes || {};
   const paths = Object.values(spec.paths ?? {});
-  const options = securityToOptions(spec, security2, securitySchemes);
+  const options = securityToOptions2(spec, security2, securitySchemes);
   for (const it of paths) {
     for (const method of methods) {
       const operation = it[method];
@@ -2023,7 +1984,7 @@ function security(spec) {
       }
       Object.assign(
         options,
-        securityToOptions(
+        securityToOptions2(
           spec,
           operation.security || [],
           securitySchemes,
@@ -2036,7 +1997,11 @@ function security(spec) {
 }
 async function generate(openapi, settings) {
   const spec = augmentSpec(
-    { spec: openapi, responses: { flattenErrorResponses: true } },
+    {
+      spec: openapi,
+      responses: { flattenErrorResponses: true },
+      pagination: settings.pagination
+    },
     false
   );
   const generator = new TypeScriptGenerator(spec, settings);
@@ -2051,6 +2016,7 @@ async function generate(openapi, settings) {
   );
   const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   settings.useTsExtension ??= true;
+  settings.readme ??= true;
   const { writer, files: writtenFiles } = createWriterProxy(
     settings.writer ?? writeFiles,
     output
@@ -2072,7 +2038,6 @@ async function generate(openapi, settings) {
     style,
     makeImport
   });
-  const options = security(spec);
   const clientName = pascalcase5((settings.name || "client").trim());
   const packageName = settings.name ? `@${spinalcase3(settings.name.trim().toLowerCase())}/sdk` : "sdk";
   const inputs = toInputs(groups, commonZod, makeImport);
@@ -2103,7 +2068,7 @@ ${template2(dispatcher_default, {})({ throwError: !style.errorAsValue, outputTyp
       {
         name: clientName,
         servers: (spec.servers ?? []).map((server) => server.url) || [],
-        options,
+        options: security(spec),
         makeImport
       },
       style
@@ -2239,12 +2204,9 @@ ${template2(dispatcher_default, {})({ throwError: !style.errorAsValue, outputTyp
       }
     };
     if (settings.readme) {
-      configFiles["README.md"] = {
-        ignoreIfExists: false,
-        content: toReadme(spec, {
-          generateSnippet: (...args) => generator.snippet(...args)
-        })
-      };
+      configFiles["README.md"] = toReadme(spec, {
+        generateSnippet: (...args) => generator.snippet(...args)
+      });
     }
     await settings.writer(settings.output, configFiles);
   }
@@ -2261,6 +2223,9 @@ function serializeModels(spec) {
     const isRequestBody = schema["x-requestbody"];
     const responseGroup = schema["x-response-group"];
     const stream = schema["x-stream"];
+    if (isRequestBody) {
+      continue;
+    }
     const folder = isResponseBody ? "outputs" : "models";
     let typeContent = "ReadableStream";
     if (!stream) {