zenko 0.1.8 → 0.1.10-beta.1

package/dist/cli.mjs

@@ -1,1340 +1,76 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 // src/cli.ts
-import * as fs from "fs";
+import * as path2 from "path";
+import { mkdir } from "fs/promises";
+import { generateFromDocument } from "@zenko/core";
+
+// src/loader.ts
 import * as path from "path";
 import { pathToFileURL } from "url";
-import { load } from "js-yaml";
-
-// 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);
+var YAML_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var JSON_EXTENSIONS = /* @__PURE__ */ new Set([".json"]);
+async function readFileText(filePath) {
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new Error(`File not found: ${filePath}`);
   }
-  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";
-}
-
-// 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}"`;
-}
-
-// 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);
-}
-
-// 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;
-}
-
-// 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);
+  return await file.text();
 }
-
-// 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;
-}
-
-// 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");
-}
-
-// src/zenko.ts
-function generateWithMetadata(spec, options = {}) {
-  const output = [];
-  const generatedTypes = /* @__PURE__ */ new Set();
-  const { strictDates = false, strictNumeric = false } = options;
-  const typesConfig = normalizeTypesConfig(options.types);
-  const schemaOptions = {
-    strictDates,
-    strictNumeric
-  };
-  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));
-    }
-  }
-  const operations = parseOperations(spec, nameMap);
-  appendHelperTypesImport(output, typesConfig, operations);
-  output.push("");
-  if (spec.components?.schemas) {
-    output.push("// Generated Zod Schemas");
-    output.push("");
-    const sortedSchemas = topologicalSort(spec.components.schemas);
-    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 optional = header.required ? "" : ".optional()";
-      return `    ${formatPropertyName(header.name)}: ${zodType}${optional},`;
-    }).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("");
+async function loadConfig(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (JSON_EXTENSIONS.has(extension)) {
+    const content = await readFileText(filePath);
+    return JSON.parse(content);
   }
-  const result = {
-    output: output.join("\n")
-  };
-  if (typesConfig.emit && typesConfig.helpers === "file" && typesConfig.helpersOutput) {
-    result.helperFile = {
-      path: typesConfig.helpersOutput,
-      content: generateHelperFile()
-    };
+  if (YAML_EXTENSIONS.has(extension)) {
+    const content = await readFileText(filePath);
+    return Bun.YAML.parse(content);
   }
-  return result;
+  const fileUrl = pathToFileURL(filePath).href;
+  const module = await import(fileUrl);
+  return module.default ?? module.config ?? module;
 }
-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("");
+async function loadSpec(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  const content = await readFileText(filePath);
+  if (YAML_EXTENSIONS.has(extension)) {
+    const parsed = Bun.YAML.parse(content);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error(`YAML spec did not resolve to an object: ${filePath}`);
     }
-  }
-}
-function generateResponseTypes(output, operations, spec, nameMap, schemaOptions) {
-  const responseTypesToGenerate = collectInlineResponseTypes(operations, spec);
-  if (responseTypesToGenerate.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
+    if (Array.isArray(parsed)) {
+      throw new Error(
+        `YAML spec produced multiple documents; provide a single document in ${filePath}`
       );
-      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 findContentType(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 parsed;
   }
-  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 [path2, 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(path2);
-        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: path2,
-          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 path2 = webhookName;
-        const pathParams = extractPathParams(path2);
-        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: path2,
-          method: normalizedMethod,
-          pathParams,
-          queryParams,
-          requestType,
-          responseType: successResponse,
-          requestHeaders,
-          errors
-        });
-      }
-    }
+  if (JSON_EXTENSIONS.has(extension)) {
+    return JSON.parse(content);
   }
-  return operations;
+  throw new Error(
+    `Unsupported specification format for ${filePath}. Expected .yaml, .yml, or .json`
+  );
 }
-function normalizeTypesConfig(config) {
+function normalizeGenerationOptions(entry, baseDir, defaults) {
+  const resolvedInput = path.isAbsolute(entry.input) ? entry.input : path.join(baseDir, entry.input);
+  const resolvedOutput = path.isAbsolute(entry.output) ? entry.output : path.join(baseDir, entry.output);
   return {
-    emit: config?.emit ?? true,
-    helpers: config?.helpers ?? "package",
-    helpersOutput: config?.helpersOutput ?? "./zenko-types",
-    treeShake: config?.treeShake ?? true
+    resolvedInput,
+    resolvedOutput,
+    strictDates: entry.strictDates ?? defaults.strictDates,
+    strictNumeric: entry.strictNumeric ?? defaults.strictNumeric,
+    types: mergeTypesConfig(defaults.types, entry.types),
+    operationIds: entry.operationIds ?? defaults.operationIds
   };
 }
-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 = resolveParameter(param, spec);
-      if (!resolved) continue;
-      const key = `${resolved.in}:${resolved.name}`;
-      parametersMap.set(key, resolved);
-    }
+function mergeTypesConfig(baseConfig, entryConfig) {
+  if (!baseConfig && !entryConfig) return void 0;
+  return {
+    ...baseConfig,
+    ...entryConfig
   };
-  addParameters(pathItem.parameters);
-  addParameters(operation.parameters);
-  return Array.from(parametersMap.values());
-}
-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 extractPathParams(path2) {
-  const params = [];
-  const matches = path2.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 = findContentType(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 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 : `${zodType}.optional()`;
-    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/cli.ts
@@ -1362,8 +98,8 @@ async function main() {
         return;
       }
       await generateSingle({
-        inputFile,
-        outputFile,
+        resolvedInput: path2.resolve(inputFile),
+        resolvedOutput: path2.resolve(outputFile),
         strictDates: parsed.strictDates,
         strictNumeric: parsed.strictNumeric
       });
@@ -1426,42 +162,26 @@ function printHelp() {
   console.log("");
   console.log("Config file format:");
   console.log(
-    '  {"types"?: { emit?, helpers?, helpersOutput? }, "schemas": [{ input, output, strictDates?, strictNumeric?, types? }] }'
+    '  {"types"?: { emit?, helpers?, helpersOutput?, optionalType?, treeShake? }, "schemas": [{ input, output, strictDates?, strictNumeric?, types? }] }'
   );
 }
 async function runFromConfig(parsed) {
   const configPath = parsed.configPath;
-  const resolvedConfigPath = path.resolve(configPath);
-  const config = await loadConfig(resolvedConfigPath);
-  validateConfig(config);
-  const baseDir = path.dirname(resolvedConfigPath);
-  const baseTypesConfig = config.types;
+  const resolvedConfigPath = path2.resolve(configPath);
+  const configDocument = await loadConfig(resolvedConfigPath);
+  validateConfig(configDocument);
+  const config = configDocument;
+  const baseDir = path2.dirname(resolvedConfigPath);
+  const defaults = {
+    strictDates: parsed.strictDates,
+    strictNumeric: parsed.strictNumeric,
+    types: config.types,
+    operationIds: void 0
+  };
   for (const entry of config.schemas) {
-    const inputFile = resolvePath(entry.input, baseDir);
-    const outputFile = resolvePath(entry.output, baseDir);
-    const typesConfig = resolveTypesConfig(baseTypesConfig, entry.types);
-    await generateSingle({
-      inputFile,
-      outputFile,
-      strictDates: entry.strictDates ?? parsed.strictDates,
-      strictNumeric: entry.strictNumeric ?? parsed.strictNumeric,
-      typesConfig
-    });
-  }
-}
-async function loadConfig(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  if (extension === ".json") {
-    const content = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(content);
+    const options = normalizeGenerationOptions(entry, baseDir, defaults);
+    await generateSingle(options);
   }
-  if (extension === ".yaml" || extension === ".yml") {
-    const content = fs.readFileSync(filePath, "utf8");
-    return load(content);
-  }
-  const fileUrl = pathToFileURL(filePath).href;
-  const module = await import(fileUrl);
-  return module.default ?? module.config ?? module;
 }
 function validateConfig(config) {
   if (!config || typeof config !== "object") {
@@ -1479,60 +199,44 @@ function validateConfig(config) {
     }
   }
 }
-function resolvePath(filePath, baseDir) {
-  return path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
-}
-function resolveTypesConfig(baseConfig, entryConfig) {
-  if (!baseConfig && !entryConfig) return void 0;
-  return {
-    ...baseConfig,
-    ...entryConfig
-  };
-}
 async function generateSingle(options) {
-  const { inputFile, outputFile, strictDates, strictNumeric, typesConfig } = options;
-  const resolvedInput = path.resolve(inputFile);
-  const resolvedOutput = path.resolve(outputFile);
-  const spec = readSpec(resolvedInput);
-  const result = generateWithMetadata(spec, {
+  const {
+    resolvedInput,
+    resolvedOutput,
+    strictDates = false,
+    strictNumeric = false,
+    types,
+    operationIds
+  } = options;
+  const spec = await loadSpec(resolvedInput);
+  const result = generateFromDocument(spec, {
     strictDates,
     strictNumeric,
-    types: typesConfig
+    types,
+    operationIds
   });
-  fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
-  fs.writeFileSync(resolvedOutput, result.output);
+  await mkdir(path2.dirname(resolvedOutput), { recursive: true });
+  await Bun.write(resolvedOutput, result.output);
   console.log(`\u2705 Generated TypeScript types in ${resolvedOutput}`);
   console.log(`\u{1F4C4} Processed ${Object.keys(spec.paths || {}).length} paths`);
   if (spec.webhooks) {
     console.log(`\u{1FA9D} Processed ${Object.keys(spec.webhooks).length} webhooks`);
   }
   if (result.helperFile) {
-    const helperPath = path.isAbsolute(result.helperFile.path) ? result.helperFile.path : path.resolve(path.dirname(resolvedOutput), result.helperFile.path);
-    const absoluteResolvedOutput = path.resolve(resolvedOutput);
-    const absoluteHelperPath = path.resolve(helperPath);
+    const helperPath = path2.isAbsolute(result.helperFile.path) ? result.helperFile.path : path2.resolve(path2.dirname(resolvedOutput), result.helperFile.path);
+    const absoluteResolvedOutput = path2.resolve(resolvedOutput);
+    const absoluteHelperPath = path2.resolve(helperPath);
     if (absoluteResolvedOutput === absoluteHelperPath) {
       console.warn(
         `\u26A0\uFE0F  Skipping helper file generation: would overwrite main output at ${absoluteResolvedOutput}`
       );
       return;
     }
-    fs.mkdirSync(path.dirname(helperPath), { recursive: true });
-    fs.writeFileSync(helperPath, result.helperFile.content, {
-      encoding: "utf8"
-    });
+    await mkdir(path2.dirname(helperPath), { recursive: true });
+    await Bun.write(helperPath, result.helperFile.content);
     console.log(`\u{1F4E6} Generated helper types in ${helperPath}`);
   }
 }
-function readSpec(filePath) {
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Input file not found: ${filePath}`);
-  }
-  const content = fs.readFileSync(filePath, "utf8");
-  if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-    return load(content);
-  }
-  return JSON.parse(content);
-}
 main().catch((error) => {
   console.error("\u274C Error:", error);
   process.exit(1);