zenko 0.1.10-beta.1 → 0.1.10-beta.2

package/dist/cli.cjs

@@ -26,7 +26,1557 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 var path2 = __toESM(require("path"), 1);
 var import_promises = require("fs/promises");
-var import_core = require("@zenko/core");
+
+// ../zenko-core/src/utils/topological-sort.ts
+function topologicalSort(schemas) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const result = [];
+  const visit = (name) => {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      return;
+    }
+    visiting.add(name);
+    const schema = schemas[name];
+    const dependencies = extractDependencies(schema);
+    for (const dep of dependencies) {
+      if (schemas[dep]) {
+        visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    result.push(name);
+  };
+  for (const name of Object.keys(schemas)) {
+    visit(name);
+  }
+  return result;
+}
+function extractDependencies(schema) {
+  const dependencies = [];
+  const traverse = (obj) => {
+    if (typeof obj !== "object" || obj === null) return;
+    if (obj.$ref && typeof obj.$ref === "string") {
+      const refName = extractRefName(obj.$ref);
+      dependencies.push(refName);
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach(traverse);
+    } else {
+      Object.values(obj).forEach(traverse);
+    }
+  };
+  traverse(schema);
+  return [...new Set(dependencies)];
+}
+function extractRefName(ref) {
+  return ref.split("/").pop() || "Unknown";
+}
+
+// ../zenko-core/src/utils/property-name.ts
+function isValidJSIdentifier(name) {
+  if (!name) return false;
+  const firstChar = name.at(0);
+  if (firstChar === void 0) return false;
+  if (!/[a-zA-Z_$]/.test(firstChar)) return false;
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) return false;
+  const reservedWords = /* @__PURE__ */ new Set([
+    "abstract",
+    "arguments",
+    "await",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "function",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "int",
+    "interface",
+    "let",
+    "long",
+    "native",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "short",
+    "static",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "transient",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "volatile",
+    "while",
+    "with",
+    "yield",
+    "async"
+  ]);
+  return !reservedWords.has(name);
+}
+function formatPropertyName(name) {
+  return isValidJSIdentifier(name) ? name : `"${name}"`;
+}
+
+// ../zenko-core/src/utils/string-utils.ts
+function toCamelCase(str) {
+  return str.replace(/-([a-zA-Z])/g, (_, letter) => letter.toUpperCase()).replace(/-+$/, "");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// ../zenko-core/src/utils/http-status.ts
+var statusNameMap = {
+  "400": "badRequest",
+  "401": "unauthorized",
+  "402": "paymentRequired",
+  "403": "forbidden",
+  "404": "notFound",
+  "405": "methodNotAllowed",
+  "406": "notAcceptable",
+  "407": "proxyAuthenticationRequired",
+  "408": "requestTimeout",
+  "409": "conflict",
+  "410": "gone",
+  "411": "lengthRequired",
+  "412": "preconditionFailed",
+  "413": "payloadTooLarge",
+  "414": "uriTooLong",
+  "415": "unsupportedMediaType",
+  "416": "rangeNotSatisfiable",
+  "417": "expectationFailed",
+  "418": "imATeapot",
+  "421": "misdirectedRequest",
+  "422": "unprocessableEntity",
+  "423": "locked",
+  "424": "failedDependency",
+  "425": "tooEarly",
+  "426": "upgradeRequired",
+  "428": "preconditionRequired",
+  "429": "tooManyRequests",
+  "431": "requestHeaderFieldsTooLarge",
+  "451": "unavailableForLegalReasons",
+  "500": "internalServerError",
+  "501": "notImplemented",
+  "502": "badGateway",
+  "503": "serviceUnavailable",
+  "504": "gatewayTimeout",
+  "505": "httpVersionNotSupported",
+  "506": "variantAlsoNegotiates",
+  "507": "insufficientStorage",
+  "508": "loopDetected",
+  "510": "notExtended",
+  "511": "networkAuthenticationRequired"
+};
+function mapStatusToIdentifier(status) {
+  if (status === "default") return "defaultError";
+  const trimmed = status.trim();
+  const mapped = statusNameMap[trimmed];
+  if (mapped) return mapped;
+  if (/^\d{3}$/.test(trimmed)) {
+    return `status${trimmed}`;
+  }
+  const sanitized = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  if (!sanitized) return "unknownError";
+  const parts = sanitized.split(/\s+/);
+  const [first, ...rest] = parts;
+  const candidate = first + rest.map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+  if (!candidate) return "unknownError";
+  return /^[a-zA-Z_$]/.test(candidate) ? candidate : `status${candidate.charAt(0).toUpperCase()}${candidate.slice(1)}`;
+}
+function isErrorStatus(status) {
+  if (status === "default") return true;
+  const code = Number(status);
+  if (!Number.isInteger(code)) return false;
+  return code >= 400;
+}
+
+// ../zenko-core/src/utils/tree-shaking.ts
+function analyzeZenkoUsage(operations) {
+  const usage = {
+    usesHeaderFn: false,
+    usesOperationDefinition: false,
+    usesOperationErrors: false
+  };
+  if (operations.length > 0) {
+    usage.usesOperationDefinition = true;
+  }
+  for (const op of operations) {
+    if (op.errors && hasAnyErrors(op.errors)) {
+      usage.usesOperationErrors = true;
+    }
+  }
+  if (operations.length > 0 && !usage.usesOperationErrors) {
+    const hasDefaultErrors = operations.some(
+      (op) => !op.errors || !hasAnyErrors(op.errors)
+    );
+    if (hasDefaultErrors) {
+      usage.usesOperationErrors = true;
+    }
+  }
+  return usage;
+}
+function generateZenkoImport(usage, mode, helpersOutput) {
+  const types = [];
+  if (usage.usesHeaderFn) types.push("HeaderFn");
+  if (usage.usesOperationDefinition) types.push("OperationDefinition");
+  if (usage.usesOperationErrors) types.push("OperationErrors");
+  if (types.length === 0) {
+    return "";
+  }
+  const importSource = mode === "package" ? '"zenko"' : `"${helpersOutput}"`;
+  return `import type { ${types.join(", ")} } from ${importSource};`;
+}
+function hasAnyErrors(errors) {
+  return Boolean(errors && Object.keys(errors).length > 0);
+}
+
+// ../zenko-core/src/utils/collect-inline-types.ts
+function collectInlineRequestTypes(operations, spec) {
+  const requestTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const requestBody = operation.requestBody;
+    if (requestBody && requestBody.content) {
+      const content = requestBody.content;
+      const jsonContent = content["application/json"];
+      if (jsonContent && jsonContent.schema) {
+        const schema = jsonContent.schema;
+        const typeName = `${capitalize(toCamelCase(op.operationId))}Request`;
+        if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+          requestTypesToGenerate.set(typeName, schema);
+        }
+      }
+    }
+  }
+  return requestTypesToGenerate;
+}
+function collectInlineResponseTypes(operations, spec) {
+  const responseTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const responses = operation.responses || {};
+    for (const [statusCode, response] of Object.entries(responses)) {
+      if (/^2\d\d$/.test(statusCode) && response.content) {
+        const content = response.content;
+        const jsonContent = content["application/json"];
+        if (jsonContent && jsonContent.schema) {
+          const schema = jsonContent.schema;
+          const typeName = `${capitalize(toCamelCase(op.operationId))}Response`;
+          if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+            responseTypesToGenerate.set(typeName, schema);
+          }
+        }
+      }
+    }
+  }
+  return responseTypesToGenerate;
+}
+function collectInlineErrorTypes(operations, spec) {
+  const errorTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const responses = operation.responses || {};
+    for (const [statusCode, response] of Object.entries(responses)) {
+      if (isErrorStatus(statusCode) && response.content) {
+        const content = response.content;
+        const jsonContent = content["application/json"];
+        if (jsonContent && jsonContent.schema) {
+          const schema = jsonContent.schema;
+          const identifier = mapStatusToIdentifier(statusCode);
+          const typeName = `${capitalize(toCamelCase(op.operationId))}${capitalize(identifier)}`;
+          if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+            errorTypesToGenerate.set(typeName, schema);
+          }
+        }
+      }
+    }
+  }
+  return errorTypesToGenerate;
+}
+
+// ../zenko-core/src/utils/collect-referenced-schemas.ts
+function findContentType(content) {
+  const contentTypes = Object.keys(content);
+  if (contentTypes.includes("application/json")) {
+    return "application/json";
+  }
+  const CONTENT_TYPE_MAP2 = {
+    "application/json": "unknown",
+    "text/csv": "string",
+    "text/plain": "string",
+    "application/octet-stream": "unknown",
+    "application/pdf": "unknown"
+  };
+  for (const contentType of contentTypes) {
+    if (contentType in CONTENT_TYPE_MAP2) {
+      return contentType;
+    }
+  }
+  return contentTypes[0] || "";
+}
+function resolveParameter(parameter, spec) {
+  if (!parameter) return void 0;
+  if (parameter.$ref) {
+    const refName = extractRefName(parameter.$ref);
+    const resolved = spec.components?.parameters?.[refName];
+    if (!resolved) return void 0;
+    const { $ref, ...overrides } = parameter;
+    return {
+      ...resolved,
+      ...overrides
+    };
+  }
+  return parameter;
+}
+function collectReferencedSchemas(operations, spec) {
+  const referenced = /* @__PURE__ */ new Set();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const rawOperation = operationLookup.get(op.operationId);
+    if (!rawOperation) continue;
+    const requestBody = rawOperation.requestBody?.content?.["application/json"]?.schema;
+    if (requestBody?.$ref) {
+      const refName = extractRefName(requestBody.$ref);
+      referenced.add(refName);
+    } else if (requestBody) {
+      const deps = extractDependencies(requestBody);
+      for (const dep of deps) {
+        if (spec.components?.schemas?.[dep]) {
+          referenced.add(dep);
+        }
+      }
+    }
+    const responses = rawOperation.responses || {};
+    for (const [, response] of Object.entries(responses)) {
+      const content = response?.content;
+      if (!content) continue;
+      const contentType = findContentType(content);
+      const responseSchema = content[contentType]?.schema;
+      if (responseSchema?.$ref) {
+        const refName = extractRefName(responseSchema.$ref);
+        referenced.add(refName);
+      } else if (responseSchema) {
+        const deps = extractDependencies(responseSchema);
+        for (const dep of deps) {
+          if (spec.components?.schemas?.[dep]) {
+            referenced.add(dep);
+          }
+        }
+      }
+    }
+    for (const param of op.queryParams) {
+      if (param.schema?.$ref) {
+        const refName = extractRefName(param.schema.$ref);
+        referenced.add(refName);
+      }
+      if (param.schema?.items?.$ref) {
+        const refName = extractRefName(param.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+    for (const header of op.requestHeaders || []) {
+      if (header.schema?.$ref) {
+        const refName = extractRefName(header.schema.$ref);
+        referenced.add(refName);
+      }
+      if (header.schema?.items?.$ref) {
+        const refName = extractRefName(header.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+    const parameters = rawOperation.parameters || [];
+    for (const param of parameters) {
+      const resolvedParam = resolveParameter(param, spec);
+      if (resolvedParam?.schema?.$ref) {
+        const refName = extractRefName(resolvedParam.schema.$ref);
+        referenced.add(refName);
+      }
+      if (resolvedParam?.schema?.items?.$ref) {
+        const refName = extractRefName(resolvedParam.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const toVisit = Array.from(referenced);
+  while (toVisit.length > 0) {
+    const schemaName = toVisit.pop();
+    if (visited.has(schemaName)) continue;
+    visited.add(schemaName);
+    const schema = spec.components?.schemas?.[schemaName];
+    if (!schema) continue;
+    const dependencies = extractDependencies(schema);
+    for (const dep of dependencies) {
+      if (spec.components?.schemas?.[dep] && !visited.has(dep)) {
+        referenced.add(dep);
+        toVisit.push(dep);
+      }
+    }
+  }
+  return referenced;
+}
+
+// ../zenko-core/src/utils/generate-helper-file.ts
+function generateHelperFile() {
+  const output = [];
+  output.push("// Generated helper types for Zenko");
+  output.push(
+    "// This file provides type definitions for operation objects and path functions"
+  );
+  output.push("");
+  output.push(
+    "export type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string"
+  );
+  output.push("");
+  output.push(
+    'export type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"'
+  );
+  output.push("");
+  output.push(
+    "export type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult"
+  );
+  output.push("");
+  output.push(
+    "export type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown)"
+  );
+  output.push("");
+  output.push(
+    "export type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;"
+  );
+  output.push("");
+  output.push(
+    "export type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
+  );
+  output.push("  method: TMethod");
+  output.push("  path: TPath");
+  output.push("  request?: TRequest");
+  output.push("  response?: TResponse");
+  output.push("  headers?: THeaders");
+  output.push("  errors?: TErrors");
+  output.push("}");
+  output.push("");
+  return output.join("\n");
+}
+
+// ../zenko-core/src/zenko.ts
+function generateWithMetadata(spec, options = {}) {
+  const output = [];
+  const generatedTypes = /* @__PURE__ */ new Set();
+  const { strictDates = false, strictNumeric = false, operationIds } = options;
+  const typesConfig = normalizeTypesConfig(options.types);
+  const schemaOptions = {
+    strictDates,
+    strictNumeric,
+    optionalType: typesConfig.optionalType
+  };
+  output.push('import { z } from "zod";');
+  const nameMap = /* @__PURE__ */ new Map();
+  if (spec.components?.schemas) {
+    for (const name of Object.keys(spec.components.schemas)) {
+      nameMap.set(name, toCamelCase(name));
+    }
+  }
+  let operations = parseOperations(spec, nameMap);
+  if (operationIds && operationIds.length > 0) {
+    const selectedIds = new Set(operationIds);
+    operations = operations.filter((op) => selectedIds.has(op.operationId));
+  }
+  appendHelperTypesImport(output, typesConfig, operations);
+  output.push("");
+  if (spec.components?.schemas) {
+    output.push("// Generated Zod Schemas");
+    output.push("");
+    let schemasToGenerate;
+    if (operationIds && operationIds.length > 0) {
+      const referencedSchemas = collectReferencedSchemas(operations, spec);
+      schemasToGenerate = Array.from(referencedSchemas);
+    } else {
+      schemasToGenerate = Object.keys(spec.components.schemas);
+    }
+    const sortedSchemas = topologicalSort(spec.components.schemas).filter(
+      (name) => schemasToGenerate.includes(name)
+    );
+    for (const name of sortedSchemas) {
+      const schema = spec.components.schemas[name];
+      const sanitizedName = nameMap.get(name);
+      output.push(
+        generateZodSchema(
+          sanitizedName,
+          schema,
+          generatedTypes,
+          schemaOptions,
+          nameMap
+        )
+      );
+      output.push("");
+      output.push(
+        `export type ${sanitizedName} = z.infer<typeof ${sanitizedName}>;`
+      );
+      output.push("");
+    }
+  }
+  output.push("// Path Functions");
+  output.push("export const paths = {");
+  for (const op of operations) {
+    const pathParamNames = op.pathParams.map((p) => p.name);
+    const hasPathParams = pathParamNames.length > 0;
+    const hasQueryParams = op.queryParams.length > 0;
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    if (!hasPathParams && !hasQueryParams) {
+      output.push(
+        `  ${formatPropertyName(camelCaseOperationId)}: () => "${op.path}",`
+      );
+      continue;
+    }
+    const alias = (n) => {
+      if (isValidJSIdentifier(n)) return n;
+      let aliased = toCamelCase(n);
+      if (!isValidJSIdentifier(aliased)) {
+        aliased = `_${aliased}`;
+      }
+      return aliased;
+    };
+    const destructPieces = [];
+    const typePieces = [];
+    for (const param of op.pathParams) {
+      destructPieces.push(
+        isValidJSIdentifier(param.name) ? param.name : `${formatPropertyName(param.name)}: ${alias(param.name)}`
+      );
+      typePieces.push(`${formatPropertyName(param.name)}: string`);
+    }
+    for (const param of op.queryParams) {
+      destructPieces.push(
+        isValidJSIdentifier(param.name) ? param.name : `${formatPropertyName(param.name)}: ${alias(param.name)}`
+      );
+      typePieces.push(
+        `${formatPropertyName(param.name)}${param.required ? "" : "?"}: ${mapQueryType(param)}`
+      );
+    }
+    const needsDefaultObject = !hasPathParams && hasQueryParams && op.queryParams.every((param) => !param.required);
+    const signatureArgs = destructPieces.length ? `{ ${destructPieces.join(", ")} }` : "{}";
+    const signature = `${signatureArgs}: { ${typePieces.join(", ")} }${needsDefaultObject ? " = {}" : ""}`;
+    const pathWithParams = op.path.replace(
+      /{([^}]+)}/g,
+      (_m, n) => `\${${alias(n)}}`
+    );
+    if (!hasQueryParams) {
+      output.push(
+        `  ${formatPropertyName(camelCaseOperationId)}: (${signature}) => \`${pathWithParams}\`,`
+      );
+      continue;
+    }
+    output.push(
+      `  ${formatPropertyName(camelCaseOperationId)}: (${signature}) => {`
+    );
+    output.push("    const params = new URLSearchParams()");
+    for (const param of op.queryParams) {
+      const accessor = isValidJSIdentifier(param.name) ? param.name : alias(toCamelCase(param.name));
+      const schema = param.schema ?? {};
+      if (schema?.type === "array") {
+        const itemValueExpression = convertQueryParamValue(
+          schema.items ?? {},
+          "value"
+        );
+        if (param.required) {
+          output.push(`    for (const value of ${accessor}) {`);
+          output.push(
+            `      params.append("${param.name}", ${itemValueExpression})`
+          );
+          output.push("    }");
+        } else {
+          output.push(`    if (${accessor} !== undefined) {`);
+          output.push(`      for (const value of ${accessor}) {`);
+          output.push(
+            `        params.append("${param.name}", ${itemValueExpression})`
+          );
+          output.push("      }");
+          output.push("    }");
+        }
+        continue;
+      }
+      const valueExpression = convertQueryParamValue(schema, accessor);
+      if (param.required) {
+        output.push(`    params.set("${param.name}", ${valueExpression})`);
+      } else {
+        output.push(`    if (${accessor} !== undefined) {`);
+        output.push(`      params.set("${param.name}", ${valueExpression})`);
+        output.push("    }");
+      }
+    }
+    output.push("    const _searchParams = params.toString()");
+    output.push(
+      `    return \`${pathWithParams}\${_searchParams ? \`?\${_searchParams}\` : ""}\``
+    );
+    output.push("  },");
+  }
+  output.push("} as const;");
+  output.push("");
+  output.push("// Header Schemas");
+  output.push("export const headerSchemas = {");
+  for (const op of operations) {
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    if (!op.requestHeaders || op.requestHeaders.length === 0) {
+      output.push(
+        `  ${formatPropertyName(camelCaseOperationId)}: z.object({}),`
+      );
+      continue;
+    }
+    const schemaFields = op.requestHeaders.map((header) => {
+      const zodType = mapHeaderToZodType(header);
+      const finalType = header.required ? zodType : applyOptionalModifier(zodType, schemaOptions.optionalType);
+      return `    ${formatPropertyName(header.name)}: ${finalType},`;
+    }).join("\n");
+    output.push(`  ${formatPropertyName(camelCaseOperationId)}: z.object({`);
+    output.push(schemaFields);
+    output.push("  }),");
+  }
+  output.push("} as const;");
+  output.push("");
+  output.push("// Header Functions");
+  output.push("export const headers = {");
+  for (const op of operations) {
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    if (!op.requestHeaders || op.requestHeaders.length === 0) {
+      output.push(
+        `  ${formatPropertyName(camelCaseOperationId)}: () => ${isValidJSIdentifier(camelCaseOperationId) ? `headerSchemas.${camelCaseOperationId}` : `headerSchemas[${formatPropertyName(camelCaseOperationId)}]`}.parse({}),`
+      );
+      continue;
+    }
+    output.push(
+      `  ${formatPropertyName(camelCaseOperationId)}: (params: z.input<${isValidJSIdentifier(camelCaseOperationId) ? `typeof headerSchemas.${camelCaseOperationId}` : `(typeof headerSchemas)[${formatPropertyName(camelCaseOperationId)}]`}>) => {`
+    );
+    output.push(
+      `    return ${isValidJSIdentifier(camelCaseOperationId) ? `headerSchemas.${camelCaseOperationId}` : `headerSchemas[${formatPropertyName(camelCaseOperationId)}]`}.parse(params)`
+    );
+    output.push("  },");
+  }
+  output.push("} as const;");
+  output.push("");
+  generateRequestTypes(output, operations, spec, nameMap, schemaOptions);
+  generateResponseTypes(output, operations, spec, nameMap, schemaOptions);
+  generateOperationTypes(output, operations, typesConfig);
+  output.push("// Operation Objects");
+  for (const op of operations) {
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    const typeAnnotation = typesConfig.emit ? `: ${capitalize(camelCaseOperationId)}Operation` : "";
+    output.push(`export const ${camelCaseOperationId}${typeAnnotation} = {`);
+    output.push(`  method: "${op.method}",`);
+    output.push(`  path: paths.${camelCaseOperationId},`);
+    appendOperationField(output, "request", op.requestType);
+    appendOperationField(output, "response", op.responseType);
+    if (op.requestHeaders && op.requestHeaders.length > 0) {
+      output.push(`  headers: headers.${camelCaseOperationId},`);
+    }
+    if (op.errors && hasAnyErrors2(op.errors)) {
+      appendErrorGroup(output, "errors", op.errors);
+    }
+    output.push("} as const;");
+    output.push("");
+  }
+  const result = {
+    output: output.join("\n")
+  };
+  if (typesConfig.emit && typesConfig.helpers === "file" && typesConfig.helpersOutput) {
+    result.helperFile = {
+      path: typesConfig.helpersOutput,
+      content: generateHelperFile()
+    };
+  }
+  return result;
+}
+function generateFromDocument(spec, options = {}) {
+  return generateWithMetadata(spec, options);
+}
+function generateRequestTypes(output, operations, spec, nameMap, schemaOptions) {
+  const requestTypesToGenerate = collectInlineRequestTypes(operations, spec);
+  if (requestTypesToGenerate.size > 0) {
+    output.push("// Generated Request Types");
+    output.push("");
+    for (const [typeName, schema] of requestTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
+  }
+}
+function generateResponseTypes(output, operations, spec, nameMap, schemaOptions) {
+  const responseTypesToGenerate = collectInlineResponseTypes(operations, spec);
+  const errorTypesToGenerate = collectInlineErrorTypes(operations, spec);
+  if (responseTypesToGenerate.size > 0 || errorTypesToGenerate.size > 0) {
+    output.push("// Generated Response Types");
+    output.push("");
+    for (const [typeName, schema] of responseTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
+    for (const [typeName, schema] of errorTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
+  }
+}
+function appendOperationField(buffer, key, value) {
+  if (!value) return;
+  buffer.push(`  ${key}: ${value},`);
+}
+function appendErrorGroup(buffer, label, errors) {
+  if (!errors || Object.keys(errors).length === 0) return;
+  buffer.push(`    ${label}: {`);
+  for (const [name, typeName] of Object.entries(errors)) {
+    buffer.push(`      ${formatPropertyName(name)}: ${typeName},`);
+  }
+  buffer.push("    },");
+}
+function hasAnyErrors2(group) {
+  return Boolean(group && Object.keys(group).length > 0);
+}
+function isRequestMethod(method) {
+  switch (method) {
+    case "get":
+    case "put":
+    case "post":
+    case "delete":
+    case "options":
+    case "head":
+    case "patch":
+    case "trace":
+      return true;
+    default:
+      return false;
+  }
+}
+var CONTENT_TYPE_MAP = {
+  "application/json": "unknown",
+  // Will use schema when available
+  "text/csv": "string",
+  "text/plain": "string",
+  // Binary/ambiguous types default to unknown for cross-platform compatibility
+  "application/octet-stream": "unknown",
+  "application/pdf": "unknown"
+};
+function findContentType2(content) {
+  const contentTypes = Object.keys(content);
+  if (contentTypes.includes("application/json")) {
+    return "application/json";
+  }
+  for (const contentType of contentTypes) {
+    if (contentType in CONTENT_TYPE_MAP) {
+      return contentType;
+    }
+  }
+  return contentTypes[0] || "";
+}
+function inferResponseType(contentType, statusCode) {
+  if (statusCode === "204" || /^3\d\d$/.test(statusCode)) {
+    return "undefined";
+  }
+  if (contentType in CONTENT_TYPE_MAP) {
+    return CONTENT_TYPE_MAP[contentType];
+  }
+  return "unknown";
+}
+function parseOperations(spec, nameMap) {
+  const operations = [];
+  if (spec.paths) {
+    for (const [path3, pathItem] of Object.entries(spec.paths)) {
+      for (const [method, operation] of Object.entries(pathItem)) {
+        const normalizedMethod = method.toLowerCase();
+        if (!isRequestMethod(normalizedMethod)) continue;
+        if (!operation.operationId) continue;
+        const pathParams = extractPathParams(path3);
+        const requestType = getRequestType(operation);
+        const { successResponse, errors } = getResponseTypes(
+          operation,
+          operation.operationId,
+          nameMap
+        );
+        const resolvedParameters = collectParameters(pathItem, operation, spec);
+        const requestHeaders = getRequestHeaders(resolvedParameters);
+        const queryParams = getQueryParams(resolvedParameters);
+        operations.push({
+          operationId: operation.operationId,
+          path: path3,
+          method: normalizedMethod,
+          pathParams,
+          queryParams,
+          requestType,
+          responseType: successResponse,
+          requestHeaders,
+          errors
+        });
+      }
+    }
+  }
+  if (spec.webhooks) {
+    for (const [webhookName, webhookItem] of Object.entries(spec.webhooks)) {
+      for (const [method, operation] of Object.entries(webhookItem)) {
+        const normalizedMethod = method.toLowerCase();
+        if (!isRequestMethod(normalizedMethod)) continue;
+        if (!operation.operationId) continue;
+        const path3 = webhookName;
+        const pathParams = extractPathParams(path3);
+        const requestType = getRequestType(operation);
+        const { successResponse, errors } = getResponseTypes(
+          operation,
+          operation.operationId
+        );
+        const resolvedParameters = collectParameters(
+          webhookItem,
+          operation,
+          spec
+        );
+        const requestHeaders = getRequestHeaders(resolvedParameters);
+        const queryParams = getQueryParams(resolvedParameters);
+        operations.push({
+          operationId: operation.operationId,
+          path: path3,
+          method: normalizedMethod,
+          pathParams,
+          queryParams,
+          requestType,
+          responseType: successResponse,
+          requestHeaders,
+          errors
+        });
+      }
+    }
+  }
+  return operations;
+}
+function normalizeTypesConfig(config) {
+  return {
+    emit: config?.emit ?? true,
+    helpers: config?.helpers ?? "package",
+    helpersOutput: config?.helpersOutput ?? "./zenko-types",
+    treeShake: config?.treeShake ?? true,
+    optionalType: config?.optionalType ?? "optional"
+  };
+}
+function appendHelperTypesImport(buffer, config, operations) {
+  if (!config.emit) return;
+  switch (config.helpers) {
+    case "package":
+      if (config.treeShake) {
+        const usage = analyzeZenkoUsage(operations);
+        const importStatement = generateZenkoImport(usage, "package");
+        if (importStatement) {
+          buffer.push(importStatement);
+        }
+      } else {
+        buffer.push(
+          'import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "zenko";'
+        );
+      }
+      return;
+    case "file":
+      if (config.treeShake) {
+        const usage = analyzeZenkoUsage(operations);
+        const importStatement = generateZenkoImport(
+          usage,
+          "file",
+          config.helpersOutput
+        );
+        if (importStatement) {
+          buffer.push(importStatement);
+        }
+      } else {
+        buffer.push(
+          `import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "${config.helpersOutput}";`
+        );
+      }
+      return;
+    case "inline":
+      buffer.push(
+        "type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;"
+      );
+      buffer.push(
+        'type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";'
+      );
+      buffer.push(
+        "type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;"
+      );
+      buffer.push(
+        "type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);"
+      );
+      buffer.push(
+        "type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;"
+      );
+      buffer.push(
+        "type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
+      );
+      buffer.push("  method: TMethod");
+      buffer.push("  path: TPath");
+      buffer.push("  request?: TRequest");
+      buffer.push("  response?: TResponse");
+      buffer.push("  headers?: THeaders");
+      buffer.push("  errors?: TErrors");
+      buffer.push("}");
+      buffer.push("");
+  }
+}
+function generateOperationTypes(buffer, operations, config) {
+  if (!config.emit) return;
+  buffer.push("// Operation Types");
+  for (const op of operations) {
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    const headerType = op.requestHeaders?.length ? isValidJSIdentifier(camelCaseOperationId) ? `typeof headers.${camelCaseOperationId}` : `(typeof headers)[${formatPropertyName(camelCaseOperationId)}]` : "undefined";
+    const requestType = wrapTypeReference(op.requestType);
+    const responseType = wrapTypeReference(op.responseType);
+    const errorsType = buildOperationErrorsType(op.errors);
+    buffer.push(
+      `export type ${capitalize(camelCaseOperationId)}Operation = OperationDefinition<`
+    );
+    buffer.push(`  "${op.method}",`);
+    buffer.push(
+      `  ${isValidJSIdentifier(camelCaseOperationId) ? `typeof paths.${camelCaseOperationId}` : `(typeof paths)[${formatPropertyName(camelCaseOperationId)}]`},`
+    );
+    buffer.push(`  ${requestType},`);
+    buffer.push(`  ${responseType},`);
+    buffer.push(`  ${headerType},`);
+    buffer.push(`  ${errorsType}`);
+    buffer.push(`>;`);
+    buffer.push("");
+  }
+}
+function buildOperationErrorsType(errors) {
+  if (!errors || !hasAnyErrors2(errors)) {
+    return "OperationErrors";
+  }
+  const errorBucket = buildErrorBucket(errors);
+  return `OperationErrors<${errorBucket}>`;
+}
+function buildErrorBucket(bucket) {
+  if (!bucket || Object.keys(bucket).length === 0) {
+    return "unknown";
+  }
+  const entries = Object.entries(bucket);
+  const accessibleEntries = entries.map(([name, type]) => {
+    const propertyKey = formatPropertyName(name);
+    const valueType = wrapErrorValueType(type);
+    return `${propertyKey}: ${valueType}`;
+  });
+  return `{ ${accessibleEntries.join("; ")} }`;
+}
+var TYPE_KEYWORDS = /* @__PURE__ */ new Set([
+  "any",
+  "unknown",
+  "never",
+  "void",
+  "null",
+  "undefined",
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "symbol"
+]);
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function wrapTypeReference(typeName) {
+  if (!typeName) return "undefined";
+  const normalized = typeName.trim();
+  if (normalized === "undefined") return "undefined";
+  if (TYPE_KEYWORDS.has(normalized)) return normalized;
+  if (normalized.startsWith("typeof ")) return normalized;
+  const arrayMatch = normalized.match(/^z\.array\((.+)\)$/);
+  if (arrayMatch) {
+    return `z.ZodArray<${wrapTypeReference(arrayMatch[1])}>`;
+  }
+  if (IDENTIFIER_PATTERN.test(normalized)) {
+    return `typeof ${normalized}`;
+  }
+  return normalized;
+}
+function wrapErrorValueType(typeName) {
+  if (!typeName) return "unknown";
+  const normalized = typeName.trim();
+  if (TYPE_KEYWORDS.has(normalized)) return normalized;
+  if (normalized.startsWith("typeof ")) return normalized;
+  const arrayMatch = normalized.match(/^z\.array\((.+)\)$/);
+  if (arrayMatch) {
+    return `z.ZodArray<${wrapErrorValueType(arrayMatch[1])}>`;
+  }
+  if (IDENTIFIER_PATTERN.test(normalized)) {
+    return `typeof ${normalized}`;
+  }
+  return normalized;
+}
+function collectParameters(pathItem, operation, spec) {
+  const parametersMap = /* @__PURE__ */ new Map();
+  const addParameters = (params) => {
+    if (!Array.isArray(params)) return;
+    for (const param of params) {
+      const resolved = resolveParameter2(param, spec);
+      if (!resolved) continue;
+      const key = `${resolved.in}:${resolved.name}`;
+      parametersMap.set(key, resolved);
+    }
+  };
+  addParameters(pathItem.parameters);
+  addParameters(operation.parameters);
+  return Array.from(parametersMap.values());
+}
+function resolveParameter2(parameter, spec) {
+  if (!parameter) return void 0;
+  if (parameter.$ref) {
+    const refName = extractRefName(parameter.$ref);
+    const resolved = spec.components?.parameters?.[refName];
+    if (!resolved) return void 0;
+    const { $ref, ...overrides } = parameter;
+    return {
+      ...resolved,
+      ...overrides
+    };
+  }
+  return parameter;
+}
+function extractPathParams(path3) {
+  const params = [];
+  const matches = path3.match(/{([^}]+)}/g);
+  if (matches) {
+    for (const match of matches) {
+      const paramName = match.slice(1, -1);
+      params.push({
+        name: paramName,
+        type: "string"
+        // OpenAPI path params are always strings
+      });
+    }
+  }
+  return params;
+}
+function getRequestType(operation) {
+  const requestBody = operation.requestBody?.content?.["application/json"]?.schema;
+  if (!requestBody) return void 0;
+  if (requestBody.$ref) {
+    return extractRefName(requestBody.$ref);
+  }
+  const typeName = `${capitalize(toCamelCase(operation.operationId))}Request`;
+  return typeName;
+}
+function getResponseTypes(operation, operationId, nameMap) {
+  const responses = operation.responses ?? {};
+  const successCodes = /* @__PURE__ */ new Map();
+  const errorEntries = [];
+  for (const [statusCode, response] of Object.entries(responses)) {
+    const content = response?.content;
+    if (!content || Object.keys(content).length === 0) {
+      if (statusCode === "204" || /^3\d\d$/.test(statusCode)) {
+        successCodes.set(statusCode, "undefined");
+      } else if (isErrorStatus(statusCode)) {
+        errorEntries.push({
+          code: statusCode,
+          schema: "undefined"
+        });
+      }
+      continue;
+    }
+    const contentType = findContentType2(content);
+    const resolvedSchema = content[contentType]?.schema;
+    if (!resolvedSchema) {
+      const inferredType = inferResponseType(contentType, statusCode);
+      if (inferredType) {
+        if (isErrorStatus(statusCode)) {
+          errorEntries.push({
+            code: statusCode,
+            schema: inferredType
+          });
+        } else if (/^2\d\d$/.test(statusCode)) {
+          successCodes.set(statusCode, inferredType);
+        }
+      }
+      continue;
+    }
+    if (isErrorStatus(statusCode)) {
+      errorEntries.push({ code: statusCode, schema: resolvedSchema });
+      continue;
+    }
+    if (/^2\d\d$/.test(statusCode)) {
+      successCodes.set(statusCode, resolvedSchema);
+    }
+  }
+  const successResponse = selectSuccessResponse(
+    successCodes,
+    operationId,
+    nameMap
+  );
+  const errors = buildErrorGroups(errorEntries, operationId, nameMap);
+  return { successResponse, errors };
+}
+function selectSuccessResponse(responses, operationId, nameMap) {
+  if (responses.size === 0) return void 0;
+  const preferredOrder = ["200", "201", "204"];
+  for (const code of preferredOrder) {
+    const schema = responses.get(code);
+    if (schema) {
+      if (typeof schema === "string") {
+        return schema;
+      }
+      return resolveResponseType(
+        schema,
+        `${capitalize(toCamelCase(operationId))}Response`,
+        nameMap
+      );
+    }
+  }
+  const [, firstSchema] = responses.entries().next().value ?? [];
+  if (!firstSchema) return void 0;
+  if (typeof firstSchema === "string") {
+    return firstSchema;
+  }
+  return resolveResponseType(
+    firstSchema,
+    `${capitalize(toCamelCase(operationId))}Response`,
+    nameMap
+  );
+}
+function buildErrorGroups(errors = [], operationId, nameMap) {
+  if (!errors.length) return void 0;
+  const group = {};
+  for (const { code, schema } of errors) {
+    const identifier = mapStatusToIdentifier(code);
+    const typeName = resolveResponseType(
+      schema,
+      `${capitalize(toCamelCase(operationId))}${capitalize(identifier)}`,
+      nameMap
+    );
+    group[identifier] = typeName;
+  }
+  return group;
+}
+function resolveResponseType(schema, fallbackName, nameMap) {
+  if (typeof schema === "string") {
+    return schema;
+  }
+  if (schema.$ref) {
+    const refName = extractRefName(schema.$ref);
+    return nameMap?.get(refName) || refName;
+  }
+  if (schema.type === "array" && schema.items?.$ref) {
+    const itemRef = extractRefName(schema.items.$ref);
+    const sanitizedItemRef = nameMap?.get(itemRef) || itemRef;
+    return `z.array(${sanitizedItemRef})`;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    return fallbackName;
+  }
+  return fallbackName;
+}
+function getRequestHeaders(parameters) {
+  const headers = [];
+  for (const param of parameters ?? []) {
+    if (param.in === "header") {
+      headers.push({
+        name: param.name,
+        description: param.description,
+        schema: param.schema,
+        required: param.required
+      });
+    }
+  }
+  return headers;
+}
+function getQueryParams(parameters) {
+  const queryParams = [];
+  for (const param of parameters ?? []) {
+    if (param.in === "query") {
+      queryParams.push({
+        name: param.name,
+        description: param.description,
+        schema: param.schema,
+        required: param.required
+      });
+    }
+  }
+  return queryParams;
+}
+function mapHeaderToZodType(header) {
+  const schema = header.schema ?? {};
+  const schemaType = schema.type;
+  switch (schemaType) {
+    case "integer":
+    case "number":
+      return "z.coerce.number()";
+    case "boolean":
+      return "z.coerce.boolean()";
+    case "array": {
+      const items = schema.items ?? { type: "string" };
+      const itemType = items.type === "integer" || items.type === "number" ? "z.coerce.number()" : items.type === "boolean" ? "z.coerce.boolean()" : "z.string()";
+      return `z.array(${itemType})`;
+    }
+    default:
+      return "z.string()";
+  }
+}
+function mapQueryType(param) {
+  return mapQuerySchemaType(param.schema);
+}
+function mapQuerySchemaType(schema) {
+  if (!schema) return "string";
+  if (schema.type === "array") {
+    const itemType = mapQuerySchemaType(schema.items);
+    return `Array<${itemType}>`;
+  }
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function convertQueryParamValue(schema, accessor) {
+  if (!schema) {
+    return `String(${accessor})`;
+  }
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return `String(${accessor})`;
+    case "boolean":
+      return `${accessor} ? "true" : "false"`;
+    default:
+      return `String(${accessor})`;
+  }
+}
+function applyOptionalModifier(zodType, optionalType) {
+  switch (optionalType) {
+    case "optional":
+      return `${zodType}.optional()`;
+    case "nullable":
+      return `${zodType}.nullable()`;
+    case "nullish":
+      return `${zodType}.nullish()`;
+  }
+}
+function generateZodSchema(name, schema, generatedTypes, options, nameMap) {
+  if (generatedTypes.has(name)) return "";
+  generatedTypes.add(name);
+  if (schema.enum) {
+    const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+    return `export const ${name} = z.enum([${enumValues}]);`;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    const allOfParts = schema.allOf.map(
+      (part) => getZodTypeFromSchema(part, options, nameMap)
+    );
+    if (allOfParts.length === 0) return `export const ${name} = z.object({});`;
+    if (allOfParts.length === 1)
+      return `export const ${name} = ${allOfParts[0]};`;
+    const first = allOfParts[0];
+    const rest = allOfParts.slice(1).map((part) => `.and(${part})`).join("");
+    return `export const ${name} = ${first}${rest};`;
+  }
+  if (schema.type === "object" || schema.properties) {
+    return `export const ${name} = ${buildZodObject(schema, options, nameMap)};`;
+  }
+  if (schema.type === "array") {
+    const itemSchema = schema.items ?? { type: "unknown" };
+    const itemType = getZodTypeFromSchema(itemSchema, options, nameMap);
+    const builder = applyStrictArrayBounds(
+      schema,
+      `z.array(${itemType})`,
+      itemSchema,
+      options.strictNumeric
+    );
+    return `export const ${name} = ${builder};`;
+  }
+  return `export const ${name} = ${getZodTypeFromSchema(schema, options, nameMap)};`;
+}
+function getZodTypeFromSchema(schema, options, nameMap) {
+  if (schema.$ref) {
+    const refName = extractRefName(schema.$ref);
+    return nameMap?.get(refName) || refName;
+  }
+  if (schema.enum) {
+    const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+    return `z.enum([${enumValues}])`;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    const allOfParts = schema.allOf.map(
+      (part) => getZodTypeFromSchema(part, options, nameMap)
+    );
+    if (allOfParts.length === 0) return "z.object({})";
+    if (allOfParts.length === 1) return allOfParts[0];
+    const first = allOfParts[0];
+    const rest = allOfParts.slice(1).map((part) => `.and(${part})`).join("");
+    return `${first}${rest}`;
+  }
+  if (schema.type === "object" || schema.properties || schema.allOf || schema.oneOf || schema.anyOf) {
+    return buildZodObject(schema, options, nameMap);
+  }
+  switch (schema.type) {
+    case "string":
+      return buildString(schema, options);
+    case "boolean":
+      return "z.boolean()";
+    case "array":
+      return `z.array(${getZodTypeFromSchema(
+        schema.items ?? { type: "unknown" },
+        options,
+        nameMap
+      )})`;
+    case "null":
+      return "z.null()";
+    case "number":
+      return buildNumber(schema, options);
+    case "integer":
+      return buildInteger(schema, options);
+    default:
+      return "z.unknown()";
+  }
+}
+function buildZodObject(schema, options, nameMap) {
+  const properties = [];
+  for (const [propName, propSchema] of Object.entries(
+    schema.properties || {}
+  )) {
+    const isRequired = schema.required?.includes(propName) ?? false;
+    const zodType = getZodTypeFromSchema(propSchema, options, nameMap);
+    const finalType = isRequired ? zodType : applyOptionalModifier(zodType, options.optionalType);
+    properties.push(`  ${formatPropertyName(propName)}: ${finalType},`);
+  }
+  if (properties.length === 0) {
+    return "z.object({})";
+  }
+  return `z.object({
+${properties.join("\n")}
+})`;
+}
+function buildString(schema, options) {
+  if (options.strictDates) {
+    switch (schema.format) {
+      case "date-time":
+        return "z.string().datetime()";
+      case "date":
+        return "z.string().date()";
+      case "time":
+        return "z.string().time()";
+      case "duration":
+        return "z.string().duration()";
+    }
+  }
+  let builder = "z.string()";
+  if (options.strictNumeric) {
+    if (typeof schema.minLength === "number") {
+      builder += `.min(${schema.minLength})`;
+    }
+    if (typeof schema.maxLength === "number") {
+      builder += `.max(${schema.maxLength})`;
+    }
+    if (schema.pattern) {
+      builder += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
+    }
+  }
+  switch (schema.format) {
+    case "uuid":
+      return `${builder}.uuid()`;
+    case "email":
+      return `${builder}.email()`;
+    case "uri":
+    case "url":
+      return `${builder}.url()`;
+    case "ipv4":
+      return `${builder}.ip({ version: "v4" })`;
+    case "ipv6":
+      return `${builder}.ip({ version: "v6" })`;
+    default:
+      return builder;
+  }
+}
+function buildNumber(schema, options) {
+  let builder = "z.number()";
+  if (options.strictNumeric) {
+    builder = applyNumericBounds(schema, builder);
+    if (typeof schema.multipleOf === "number" && schema.multipleOf !== 0) {
+      builder += `.refine((value) => Math.abs(value / ${schema.multipleOf} - Math.round(value / ${schema.multipleOf})) < Number.EPSILON, { message: "Must be a multiple of ${schema.multipleOf}" })`;
+    }
+  }
+  return builder;
+}
+function buildInteger(schema, options) {
+  let builder = buildNumber(schema, options);
+  builder += ".int()";
+  return builder;
+}
+function applyStrictArrayBounds(schema, builder, itemSchema, enforceBounds) {
+  if (!enforceBounds) {
+    return builder;
+  }
+  if (typeof schema.minItems === "number") {
+    builder += `.min(${schema.minItems})`;
+  }
+  if (typeof schema.maxItems === "number") {
+    builder += `.max(${schema.maxItems})`;
+  }
+  if (schema.uniqueItems && isPrimitiveLike(itemSchema)) {
+    builder += '.refine((items) => new Set(items).size === items.length, { message: "Items must be unique" })';
+  }
+  return builder;
+}
+function isPrimitiveLike(schema) {
+  if (schema?.$ref) return false;
+  const primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+  return primitiveTypes.has(schema?.type);
+}
+function applyNumericBounds(schema, builder) {
+  if (typeof schema.minimum === "number") {
+    if (schema.exclusiveMinimum === true) {
+      builder += `.gt(${schema.minimum})`;
+    } else {
+      builder += `.min(${schema.minimum})`;
+    }
+  } else if (typeof schema.exclusiveMinimum === "number") {
+    builder += `.gt(${schema.exclusiveMinimum})`;
+  }
+  if (typeof schema.maximum === "number") {
+    if (schema.exclusiveMaximum === true) {
+      builder += `.lt(${schema.maximum})`;
+    } else {
+      builder += `.max(${schema.maximum})`;
+    }
+  } else if (typeof schema.exclusiveMaximum === "number") {
+    builder += `.lt(${schema.exclusiveMaximum})`;
+  }
+  return builder;
+}
 
 // src/loader.ts
 var path = __toESM(require("path"), 1);
@@ -232,7 +1782,7 @@ async function generateSingle(options) {
     operationIds
   } = options;
   const spec = await loadSpec(resolvedInput);
-  const result = (0, import_core.generateFromDocument)(spec, {
+  const result = generateFromDocument(spec, {
     strictDates,
     strictNumeric,
     types,