zenko 0.1.12 → 0.1.13

package/dist/cli.cjs

@@ -1,1743 +1,3 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var import_url = require("url");
-
-// 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";
-}
-
-// 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/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);
-}
-
-// src/utils/schema-utils.ts
-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 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;
-}
-
-// src/utils/collect-referenced-schemas.ts
-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;
-}
-
-// src/core/schema-generator.ts
-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 baseType = getZodTypeFromSchema(propSchema, options, nameMap);
-    const withOptional = applyOptionalModifier(baseType, options.optionalType);
-    const withDefault = options.optionalType !== "nullable" ? applyDefaultModifier(withOptional, propSchema) : withOptional;
-    const finalType = isRequired ? baseType : withDefault;
-    properties.push(`  ${formatPropertyName(propName)}: ${finalType},`);
-  }
-  if (properties.length === 0) {
-    return "z.object({})";
-  }
-  return `z.object({
-${properties.join("\n")}
-})`;
-}
-function buildString(schema, options) {
-  if (schema.format === "binary") {
-    return `(typeof Blob === "undefined" ? z.unknown() : z.instanceof(Blob))`;
-  }
-  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 applyDefaultModifier(zodType, schema) {
-  if (!schema || schema.default === void 0) return zodType;
-  return `${zodType}.default(${JSON.stringify(schema.default)})`;
-}
-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/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/core/operation-parser.ts
-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, nameMap);
-        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, nameMap);
-        const { successResponse, errors } = getResponseTypes(
-          operation,
-          operation.operationId,
-          nameMap
-        );
-        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
-        });
-      }
-    }
-  }
-  return operations;
-}
-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);
-    }
-  };
-  addParameters(pathItem.parameters);
-  addParameters(operation.parameters);
-  return Array.from(parametersMap.values());
-}
-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"
-      });
-    }
-  }
-  return params;
-}
-function getRequestType(operation, nameMap) {
-  const requestBodySchema = getRequestBodySchema(operation);
-  if (!requestBodySchema) return void 0;
-  if (requestBodySchema.$ref) {
-    const refName = extractRefName(requestBodySchema.$ref);
-    return nameMap?.get(refName) || refName;
-  }
-  const typeName = `${capitalize(toCamelCase(operation.operationId))}Request`;
-  return typeName;
-}
-function getRequestBodySchema(operation) {
-  const content = operation?.requestBody?.content;
-  if (!content || Object.keys(content).length === 0) return void 0;
-  const preferredTypes = [
-    "application/json",
-    "multipart/form-data",
-    "application/x-www-form-urlencoded"
-  ];
-  for (const t of preferredTypes) {
-    const schema = content[t]?.schema;
-    if (schema) return schema;
-  }
-  return void 0;
-}
-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 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;
-  }
-}
-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";
-}
-
-// 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 schema = findRequestBodySchema(content);
-      if (!schema) continue;
-      const typeName = `${capitalize(toCamelCase(op.operationId))}Request`;
-      if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
-        requestTypesToGenerate.set(typeName, schema);
-      }
-    }
-  }
-  return requestTypesToGenerate;
-}
-function findRequestBodySchema(content) {
-  const preferredTypes = [
-    "application/json",
-    "multipart/form-data",
-    "application/x-www-form-urlencoded"
-  ];
-  for (const t of preferredTypes) {
-    const schema = content[t]?.schema;
-    if (schema) return schema;
-  }
-  return void 0;
-}
-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/generator/inline-types.ts
-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);
-  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
-      );
-      output.push(generatedSchema);
-      output.push("");
-      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
-      output.push("");
-    }
-  }
-}
-
-// 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, 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 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 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 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})`;
-  }
-}
-
-// src/cli.ts
-async function main() {
-  const args = process.argv.slice(2);
-  const parsed = parseArgs(args);
-  if (parsed.showHelp || !parsed.configPath && parsed.positional.length === 0) {
-    printHelp();
-    process.exit(parsed.showHelp ? 0 : 1);
-    return;
-  }
-  try {
-    if (parsed.configPath) {
-      await runFromConfig(parsed);
-    } else {
-      if (parsed.positional.length !== 2) {
-        printHelp();
-        process.exit(1);
-        return;
-      }
-      const [inputFile, outputFile] = parsed.positional;
-      if (!inputFile || !outputFile) {
-        printHelp();
-        process.exit(1);
-        return;
-      }
-      await generateSingle({
-        inputFile,
-        outputFile,
-        strictDates: parsed.strictDates,
-        strictNumeric: parsed.strictNumeric
-      });
-    }
-  } catch (error) {
-    console.error("\u274C Error:", error);
-    process.exit(1);
-  }
-}
-function parseArgs(args) {
-  const parsed = {
-    showHelp: false,
-    strictDates: false,
-    strictNumeric: false,
-    positional: []
-  };
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "-h" || arg === "--help") {
-      parsed.showHelp = true;
-      continue;
-    }
-    if (arg === "--strict-dates") {
-      parsed.strictDates = true;
-      continue;
-    }
-    if (arg === "--strict-numeric") {
-      parsed.strictNumeric = true;
-      continue;
-    }
-    if (arg === "--config" || arg === "-c") {
-      const next = args[index + 1];
-      if (!next) {
-        throw new Error("--config flag requires a file path");
-      }
-      parsed.configPath = next;
-      index += 1;
-      continue;
-    }
-    parsed.positional.push(arg);
-  }
-  return parsed;
-}
-function printHelp() {
-  console.log("Usage:");
-  console.log("  zenko <input-file> <output-file> [options]");
-  console.log("  zenko --config <config-file> [options]");
-  console.log("");
-  console.log("Options:");
-  console.log("  -h, --help          Show this help message");
-  console.log(
-    "  --strict-dates      Use ISO datetime parsing (can be set per config entry)"
-  );
-  console.log(
-    "  --strict-numeric    Preserve numeric min/max bounds (can be set per config entry)"
-  );
-  console.log(
-    "  -c, --config        Path to config file (JSON, YAML, or JS module)"
-  );
-  console.log("");
-  console.log("Config file format:");
-  console.log(
-    '  {"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;
-  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,
-      operationIds: entry.operationIds
-    });
-  }
-}
-async function loadConfig(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  if (extension === ".json") {
-    const content = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(content);
-  }
-  if (extension === ".yaml" || extension === ".yml") {
-    const content = fs.readFileSync(filePath, "utf8");
-    return Bun.YAML.parse(content);
-  }
-  const fileUrl = (0, import_url.pathToFileURL)(filePath).href;
-  const module2 = await import(fileUrl);
-  return module2.default ?? module2.config ?? module2;
-}
-function validateConfig(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error("Config file must export an object");
-  }
-  if (!Array.isArray(config.schemas)) {
-    throw new Error("Config file must contain a 'schemas' array");
-  }
-  for (const entry of config.schemas) {
-    if (!entry || typeof entry !== "object") {
-      throw new Error("Each schema entry must be an object");
-    }
-    if (typeof entry.input !== "string" || typeof entry.output !== "string") {
-      throw new Error("Each schema entry requires 'input' and 'output' paths");
-    }
-  }
-}
-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,
-    operationIds
-  } = options;
-  const resolvedInput = path.resolve(inputFile);
-  const resolvedOutput = path.resolve(outputFile);
-  const spec = readSpec(resolvedInput);
-  const result = generateWithMetadata(spec, {
-    strictDates,
-    strictNumeric,
-    types: typesConfig,
-    operationIds
-  });
-  fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
-  fs.writeFileSync(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);
-    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"
-    });
-    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 Bun.YAML.parse(content);
-  }
-  return JSON.parse(content);
-}
-main().catch((error) => {
-  console.error("\u274C Error:", error);
-  process.exit(1);
-});
+"use strict"; function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _chunk7VP5JZCLcjs = require('./chunk-7VP5JZCL.cjs');var _fs = require('fs'); var i = _interopRequireWildcard(_fs);var _path = require('path'); var n = _interopRequireWildcard(_path);var _url = require('url');async function F(){let t=process.argv.slice(2),e=S(t);if(e.showHelp||!e.configPath&&e.positional.length===0){h(),process.exit(e.showHelp?0:1);return}try{if(e.configPath)await v(e);else{if(e.positional.length!==2){h(),process.exit(1);return}let[s,o]=e.positional;if(!s||!o){h(),process.exit(1);return}await w({inputFile:s,outputFile:o,strictDates:e.strictDates,strictNumeric:e.strictNumeric})}}catch(s){console.error("\u274C Error:",s),process.exit(1)}}function S(t){let e={showHelp:!1,strictDates:!1,strictNumeric:!1,positional:[]};for(let s=0;s<t.length;s+=1){let o=t[s];if(o==="-h"||o==="--help"){e.showHelp=!0;continue}if(o==="--strict-dates"){e.strictDates=!0;continue}if(o==="--strict-numeric"){e.strictNumeric=!0;continue}if(o==="--config"||o==="-c"){let r=t[s+1];if(!r)throw new Error("--config flag requires a file path");e.configPath=r,s+=1;continue}e.positional.push(o)}return e}function h(){console.log("Usage:"),console.log("  zenko <input-file> <output-file> [options]"),console.log("  zenko --config <config-file> [options]"),console.log(""),console.log("Options:"),console.log("  -h, --help          Show this help message"),console.log("  --strict-dates      Use ISO datetime parsing (can be set per config entry)"),console.log("  --strict-numeric    Preserve numeric min/max bounds (can be set per config entry)"),console.log("  -c, --config        Path to config file (JSON, YAML, or JS module)"),console.log(""),console.log("Config file format:"),console.log('  {"types"?: { emit?, helpers?, helpersOutput?, optionalType?, treeShake? }, "schemas": [{ input, output, strictDates?, strictNumeric?, types? }] }')}async function v(t){let e=t.configPath,s=n.resolve(e),o=await A(s);N(o);let r=n.dirname(s),f=o.types;for(let c of o.schemas){let g=d(c.input,r),a=d(c.output,r),p=O(f,c.types);await w({inputFile:g,outputFile:a,strictDates:_nullishCoalesce(c.strictDates, () => (t.strictDates)),strictNumeric:_nullishCoalesce(c.strictNumeric, () => (t.strictNumeric)),typesConfig:p,operationIds:c.operationIds})}}async function A(t){let e=n.extname(t).toLowerCase();if(e===".json"){let r=i.readFileSync(t,"utf8");return JSON.parse(r)}if(e===".yaml"||e===".yml"){let r=i.readFileSync(t,"utf8");return Bun.YAML.parse(r)}let o=await Promise.resolve().then(() => _interopRequireWildcard(require(_url.pathToFileURL.call(void 0, t).href)));return _nullishCoalesce(_nullishCoalesce(o.default, () => (o.config)), () => (o))}function N(t){if(!t||typeof t!="object")throw new Error("Config file must export an object");if(!Array.isArray(t.schemas))throw new Error("Config file must contain a 'schemas' array");for(let e of t.schemas){if(!e||typeof e!="object")throw new Error("Each schema entry must be an object");if(typeof e.input!="string"||typeof e.output!="string")throw new Error("Each schema entry requires 'input' and 'output' paths")}}function d(t,e){return n.isAbsolute(t)?t:n.join(e,t)}function O(t,e){if(!(!t&&!e))return{...t,...e}}async function w(t){let{inputFile:e,outputFile:s,strictDates:o,strictNumeric:r,typesConfig:f,operationIds:c}=t,g=n.resolve(e),a=n.resolve(s),p=P(g),l=_chunk7VP5JZCLcjs.a.call(void 0, p,{strictDates:o,strictNumeric:r,types:f,operationIds:c});if(i.mkdirSync(n.dirname(a),{recursive:!0}),i.writeFileSync(a,l.output),console.log(`\u2705 Generated TypeScript types in ${a}`),console.log(`\u{1F4C4} Processed ${Object.keys(p.paths||{}).length} paths`),p.webhooks&&console.log(`\u{1FA9D} Processed ${Object.keys(p.webhooks).length} webhooks`),l.helperFile){let u=n.isAbsolute(l.helperFile.path)?l.helperFile.path:n.resolve(n.dirname(a),l.helperFile.path),y=n.resolve(a),C=n.resolve(u);if(y===C){console.warn(`\u26A0\uFE0F  Skipping helper file generation: would overwrite main output at ${y}`);return}i.mkdirSync(n.dirname(u),{recursive:!0}),i.writeFileSync(u,l.helperFile.content,{encoding:"utf8"}),console.log(`\u{1F4E6} Generated helper types in ${u}`)}}function P(t){if(!i.existsSync(t))throw new Error(`Input file not found: ${t}`);let e=i.readFileSync(t,"utf8");return t.endsWith(".yaml")||t.endsWith(".yml")?Bun.YAML.parse(e):JSON.parse(e)}F().catch(t=>{console.error("\u274C Error:",t),process.exit(1)});
 //# sourceMappingURL=cli.cjs.map