@cerios/openapi-to-zod 1.4.0 → 1.5.0

package/dist/internal.js

@@ -1,2025 +0,0 @@
-"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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal.ts
-var internal_exports = {};
-__export(internal_exports, {
-  LRUCache: () => LRUCache,
-  OperationFiltersSchema: () => OperationFiltersSchema,
-  PropertyGenerator: () => PropertyGenerator,
-  RequestResponseOptionsSchema: () => RequestResponseOptionsSchema,
-  buildDateTimeValidation: () => buildDateTimeValidation,
-  createFilterStatistics: () => createFilterStatistics,
-  createTypeScriptLoader: () => createTypeScriptLoader,
-  escapeJSDoc: () => escapeJSDoc,
-  executeBatch: () => executeBatch,
-  formatConfigValidationError: () => formatConfigValidationError,
-  formatFilterStatistics: () => formatFilterStatistics,
-  getBatchExitCode: () => getBatchExitCode,
-  getResponseParseMethod: () => getResponseParseMethod,
-  mergeParameters: () => mergeParameters,
-  resolveParameterRef: () => resolveParameterRef,
-  resolveRef: () => resolveRef2,
-  resolveRequestBodyRef: () => resolveRequestBodyRef,
-  resolveResponseRef: () => resolveResponseRef,
-  shouldIncludeOperation: () => shouldIncludeOperation,
-  stripPathPrefix: () => stripPathPrefix,
-  stripPrefix: () => stripPrefix,
-  toCamelCase: () => toCamelCase,
-  toPascalCase: () => toPascalCase,
-  validateFilters: () => validateFilters
-});
-module.exports = __toCommonJS(internal_exports);
-
-// src/errors.ts
-var GeneratorError = class extends Error {
-  constructor(message, code, context) {
-    var _a;
-    super(message);
-    this.code = code;
-    this.context = context;
-    this.name = "GeneratorError";
-    (_a = Error.captureStackTrace) == null ? void 0 : _a.call(Error, this, this.constructor);
-  }
-};
-var ConfigurationError = class extends GeneratorError {
-  constructor(message, context) {
-    super(message, "CONFIGURATION_ERROR", context);
-    this.name = "ConfigurationError";
-  }
-};
-
-// src/batch-executor.ts
-async function processSpec(spec, index, total, createGenerator) {
-  const specInput = spec.input || "spec";
-  const specOutput = spec.output || "output";
-  console.log(`Processing [${index + 1}/${total}] ${specInput}...`);
-  try {
-    const generator = createGenerator(spec);
-    generator.generate();
-    return {
-      spec,
-      success: true
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`\u2717 Failed to generate ${specOutput}: ${errorMessage}`);
-    return {
-      spec,
-      success: false,
-      error: errorMessage
-    };
-  }
-}
-async function executeParallel(specs, createGenerator, batchSize) {
-  console.log(`
-Executing ${specs.length} specification(s) in parallel (batch size: ${batchSize})...
-`);
-  const results = [];
-  for (let i = 0; i < specs.length; i += batchSize) {
-    const batch = specs.slice(i, Math.min(i + batchSize, specs.length));
-    const batchPromises = batch.map(
-      (spec, batchIndex) => processSpec(spec, i + batchIndex, specs.length, createGenerator)
-    );
-    const batchResults = await Promise.allSettled(batchPromises);
-    for (let j = 0; j < batchResults.length; j++) {
-      const result = batchResults[j];
-      if (result.status === "fulfilled") {
-        results.push(result.value);
-      } else {
-        results.push({
-          spec: batch[j],
-          success: false,
-          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
-        });
-      }
-    }
-  }
-  return results;
-}
-async function executeSequential(specs, createGenerator) {
-  console.log(`
-Executing ${specs.length} spec(s) sequentially...
-`);
-  const results = [];
-  for (let i = 0; i < specs.length; i++) {
-    const result = await processSpec(specs[i], i, specs.length, createGenerator);
-    results.push(result);
-  }
-  return results;
-}
-function printSummary(summary) {
-  console.log(`
-${"=".repeat(50)}`);
-  console.log("Batch Execution Summary");
-  console.log("=".repeat(50));
-  console.log(`Total specs: ${summary.total}`);
-  console.log(`Successful: ${summary.successful}`);
-  console.log(`Failed: ${summary.failed}`);
-  if (summary.failed > 0) {
-    console.log("\nFailed specs:");
-    for (const result of summary.results) {
-      if (!result.success) {
-        const specInput = result.spec.input || "spec";
-        console.error(`  \u2717 ${specInput}`);
-        console.error(`    Error: ${result.error}`);
-      }
-    }
-  }
-  console.log(`${"=".repeat(50)}
-`);
-}
-async function executeBatch(specs, executionMode = "parallel", createGenerator, batchSize) {
-  if (specs.length === 0) {
-    throw new ConfigurationError("No specs provided for batch execution", { specsCount: 0, executionMode });
-  }
-  let results = [];
-  try {
-    results = executionMode === "parallel" ? await executeParallel(specs, createGenerator, batchSize) : await executeSequential(specs, createGenerator);
-    const summary = {
-      total: results.length,
-      successful: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      results
-    };
-    printSummary(summary);
-    return summary;
-  } finally {
-    if (results.length > batchSize) {
-      for (const result of results) {
-        if (result.spec) {
-          result.spec = null;
-        }
-      }
-      if (global.gc) {
-        global.gc();
-      }
-    }
-  }
-}
-function getBatchExitCode(summary) {
-  return summary.failed > 0 ? 1 : 0;
-}
-
-// src/utils/lru-cache.ts
-var LRUCache = class {
-  constructor(maxSize) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = maxSize;
-  }
-  get capacity() {
-    return this.maxSize;
-  }
-  get(key) {
-    if (!this.cache.has(key)) return void 0;
-    const value = this.cache.get(key);
-    if (value === void 0) return void 0;
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== void 0) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  has(key) {
-    return this.cache.has(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  size() {
-    return this.cache.size;
-  }
-};
-
-// src/utils/name-utils.ts
-function sanitizeIdentifier(str) {
-  return str.replace(/[^a-zA-Z0-9._\-\s]+/g, "_");
-}
-function toCamelCase(str, options) {
-  const sanitized = sanitizeIdentifier(str);
-  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
-  let name;
-  if (words.length === 0) {
-    name = str.charAt(0).toLowerCase() + str.slice(1);
-  } else if (words.length === 1) {
-    name = words[0].charAt(0).toLowerCase() + words[0].slice(1);
-  } else {
-    name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-  }
-  if (options == null ? void 0 : options.prefix) {
-    const prefix = options.prefix.charAt(0).toLowerCase() + options.prefix.slice(1);
-    name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
-  }
-  if (options == null ? void 0 : options.suffix) {
-    const suffix = options.suffix.charAt(0).toUpperCase() + options.suffix.slice(1);
-    name = name + suffix;
-  }
-  return name;
-}
-function toPascalCase(str) {
-  const stringValue = String(str);
-  const isAlreadyValidCase = /^[a-zA-Z][a-zA-Z0-9]*$/.test(stringValue);
-  if (isAlreadyValidCase) {
-    return stringValue.charAt(0).toUpperCase() + stringValue.slice(1);
-  }
-  const sanitized = sanitizeIdentifier(stringValue);
-  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
-  let result;
-  if (words.length === 0) {
-    result = "Value";
-  } else {
-    result = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-  }
-  if (/^\d/.test(result)) {
-    result = `N${result}`;
-  }
-  if (!result || /^_+$/.test(result)) {
-    return "Value";
-  }
-  return result;
-}
-function resolveRef(ref) {
-  const parts = ref.split("/");
-  return parts[parts.length - 1];
-}
-
-// src/utils/pattern-utils.ts
-var import_minimatch = require("minimatch");
-function isValidGlobPattern(pattern) {
-  try {
-    new import_minimatch.minimatch.Minimatch(pattern);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isGlobPattern(pattern) {
-  return /[*?[\]{}!]/.test(pattern);
-}
-function stripPrefix(input, pattern, ensureLeadingChar) {
-  if (!pattern) {
-    return input;
-  }
-  if (isGlobPattern(pattern) && !isValidGlobPattern(pattern)) {
-    console.warn(`\u26A0\uFE0F  Invalid glob pattern "${pattern}": Pattern is malformed`);
-    return input;
-  }
-  if (isGlobPattern(pattern)) {
-    let longestMatch = -1;
-    for (let i = 1; i <= input.length; i++) {
-      const testPrefix = input.substring(0, i);
-      if ((0, import_minimatch.minimatch)(testPrefix, pattern)) {
-        longestMatch = i;
-      }
-    }
-    if (longestMatch > 0) {
-      const stripped = input.substring(longestMatch);
-      if (ensureLeadingChar) {
-        if (stripped === "") {
-          return ensureLeadingChar;
-        }
-        if (!stripped.startsWith(ensureLeadingChar)) {
-          return `${ensureLeadingChar}${stripped}`;
-        }
-      }
-      return stripped === "" && !ensureLeadingChar ? input : stripped;
-    }
-    return input;
-  }
-  if (input.startsWith(pattern)) {
-    const stripped = input.substring(pattern.length);
-    if (ensureLeadingChar) {
-      if (stripped === "") {
-        return ensureLeadingChar;
-      }
-      if (!stripped.startsWith(ensureLeadingChar)) {
-        return `${ensureLeadingChar}${stripped}`;
-      }
-    }
-    return stripped;
-  }
-  return input;
-}
-function stripPathPrefix(path, pattern) {
-  if (!pattern) {
-    return path;
-  }
-  if (!isGlobPattern(pattern)) {
-    let normalizedPattern = pattern.trim();
-    if (!normalizedPattern.startsWith("/")) {
-      normalizedPattern = `/${normalizedPattern}`;
-    }
-    if (normalizedPattern.endsWith("/") && normalizedPattern !== "/") {
-      normalizedPattern = normalizedPattern.slice(0, -1);
-    }
-    return stripPrefix(path, normalizedPattern, "/");
-  }
-  return stripPrefix(path, pattern, "/");
-}
-
-// src/utils/string-utils.ts
-function escapeDescription(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-}
-function escapePattern(str) {
-  return str.replace(/(?<!\\)\//g, "\\/");
-}
-function escapeJSDoc(str) {
-  return str.replace(/\*\//g, "*\\/");
-}
-function wrapNullable(validation, isNullable2) {
-  return isNullable2 ? `${validation}.nullable()` : validation;
-}
-function isNullable(schema, defaultNullable = false) {
-  if (schema.nullable === true) {
-    return true;
-  }
-  if (schema.nullable === false) {
-    return false;
-  }
-  if (Array.isArray(schema.type)) {
-    return schema.type.includes("null");
-  }
-  return defaultNullable;
-}
-function getPrimaryType(schema) {
-  if (Array.isArray(schema.type)) {
-    const nonNullType = schema.type.find((t) => t !== "null");
-    return nonNullType;
-  }
-  return schema.type;
-}
-function hasMultipleTypes(schema) {
-  if (Array.isArray(schema.type)) {
-    const nonNullTypes = schema.type.filter((t) => t !== "null");
-    return nonNullTypes.length > 1;
-  }
-  return false;
-}
-function addDescription(validation, description, useDescribe) {
-  if (!description || !useDescribe) return validation;
-  const escapedDesc = escapeDescription(description);
-  return `${validation}.describe("${escapedDesc}")`;
-}
-
-// src/validators/array-validator.ts
-function generateArrayValidation(schema, context) {
-  var _a;
-  let validation;
-  if (schema.prefixItems && schema.prefixItems.length > 0) {
-    const tupleItems = schema.prefixItems.map((item) => context.generatePropertySchema(item, context.currentSchema));
-    validation = `z.tuple([${tupleItems.join(", ")}])`;
-    if (schema.items) {
-      const restSchema = context.generatePropertySchema(schema.items, context.currentSchema);
-      validation += `.rest(${restSchema})`;
-    } else if (schema.unevaluatedItems && typeof schema.unevaluatedItems === "object") {
-      const restSchema = context.generatePropertySchema(schema.unevaluatedItems, context.currentSchema);
-      validation += `.rest(${restSchema})`;
-    }
-  } else if (schema.items) {
-    const itemSchema = context.generatePropertySchema(schema.items, context.currentSchema);
-    validation = `z.array(${itemSchema})`;
-    if (schema.minItems !== void 0) {
-      validation += `.min(${schema.minItems})`;
-    }
-    if (schema.maxItems !== void 0) {
-      validation += `.max(${schema.maxItems})`;
-    }
-    if (schema.uniqueItems === true) {
-      validation += `.refine((items) => new Set(items).size === items.length, { message: "Array items must be unique" })`;
-    }
-  } else {
-    validation = "z.array(z.unknown())";
-  }
-  if (schema.contains) {
-    const containsSchema = context.generatePropertySchema(schema.contains, context.currentSchema);
-    const minCount = (_a = schema.minContains) != null ? _a : 1;
-    const maxCount = schema.maxContains;
-    if (maxCount !== void 0) {
-      validation += `.refine((arr) => { const matches = arr.filter(item => ${containsSchema}.safeParse(item).success); return matches.length >= ${minCount} && matches.length <= ${maxCount}; }, { message: "Array must contain between ${minCount} and ${maxCount} items matching the schema" })`;
-    } else {
-      validation += `.refine((arr) => arr.filter(item => ${containsSchema}.safeParse(item).success).length >= ${minCount}, { message: "Array must contain at least ${minCount} item(s) matching the schema" })`;
-    }
-  }
-  if (schema.unevaluatedItems === false && schema.prefixItems && schema.prefixItems.length > 0 && !schema.items) {
-    const prefixCount = schema.prefixItems.length;
-    validation += `.refine((arr) => arr.length <= ${prefixCount}, { message: "No unevaluated items allowed beyond prefix items" })`;
-  }
-  return addDescription(validation, schema.description, context.useDescribe);
-}
-
-// src/validators/composition-validator.ts
-function isDiscriminatorRequired(schemas, discriminator, context) {
-  const invalidSchemas = [];
-  for (const schema of schemas) {
-    const resolved = resolveSchema(schema, context);
-    const required = resolved.required || [];
-    if (!required.includes(discriminator)) {
-      const schemaName = schema.$ref ? schema.$ref.split("/").pop() || "inline" : "inline";
-      invalidSchemas.push(schemaName);
-    }
-  }
-  return {
-    valid: invalidSchemas.length === 0,
-    invalidSchemas
-  };
-}
-function generateUnion(schemas, discriminator, isNullable2, context, options, currentSchema) {
-  if (schemas.length === 0) {
-    console.warn(
-      "[openapi-to-zod] Warning: Empty oneOf/anyOf array encountered. This is likely a malformed OpenAPI spec. Generating z.never() as fallback."
-    );
-    return wrapNullable(
-      'z.never().describe("Empty oneOf/anyOf in OpenAPI spec - no valid schema defined")',
-      isNullable2
-    );
-  }
-  if (schemas.length === 1) {
-    let singleSchema = context.generatePropertySchema(schemas[0], currentSchema, false, true);
-    if ((options == null ? void 0 : options.passthrough) && !singleSchema.includes(".catchall(")) {
-      singleSchema = `${singleSchema}.catchall(z.unknown())`;
-    }
-    return wrapNullable(singleSchema, isNullable2);
-  }
-  if (discriminator) {
-    let resolvedSchemas = schemas;
-    if ((options == null ? void 0 : options.discriminatorMapping) && context.resolveDiscriminatorMapping) {
-      resolvedSchemas = context.resolveDiscriminatorMapping(options.discriminatorMapping, schemas);
-    }
-    const discriminatorCheck = isDiscriminatorRequired(resolvedSchemas, discriminator, context);
-    if (!discriminatorCheck.valid) {
-      console.warn(
-        `[openapi-to-zod] Warning: Discriminator "${discriminator}" is not required in schemas: ${discriminatorCheck.invalidSchemas.join(", ")}. Falling back to z.union() instead of z.discriminatedUnion().`
-      );
-      let schemaStrings3 = resolvedSchemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
-      if (options == null ? void 0 : options.passthrough) {
-        schemaStrings3 = schemaStrings3.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
-      }
-      const fallbackDescription = `Discriminator "${discriminator}" is optional in some schemas (${discriminatorCheck.invalidSchemas.join(", ")}), using z.union() instead of z.discriminatedUnion()`;
-      const union3 = `z.union([${schemaStrings3.join(", ")}]).describe("${fallbackDescription}")`;
-      return wrapNullable(union3, isNullable2);
-    }
-    let schemaStrings2 = resolvedSchemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
-    if (options == null ? void 0 : options.passthrough) {
-      schemaStrings2 = schemaStrings2.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
-    }
-    const union2 = `z.discriminatedUnion("${discriminator}", [${schemaStrings2.join(", ")}])`;
-    return wrapNullable(union2, isNullable2);
-  }
-  let schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
-  if (options == null ? void 0 : options.passthrough) {
-    schemaStrings = schemaStrings.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
-  }
-  const union = `z.union([${schemaStrings.join(", ")}])`;
-  return wrapNullable(union, isNullable2);
-}
-function resolveSchema(schema, context) {
-  if (schema.$ref && context.resolveSchemaRef) {
-    const resolved = context.resolveSchemaRef(schema.$ref);
-    if (resolved) {
-      return resolved;
-    }
-  }
-  return schema;
-}
-function collectProperties(schema, context) {
-  const resolved = resolveSchema(schema, context);
-  const props = /* @__PURE__ */ new Map();
-  const sourceName = schema.$ref ? schema.$ref.split("/").pop() || "unknown" : "inline";
-  if (resolved.properties) {
-    for (const [key, value] of Object.entries(resolved.properties)) {
-      props.set(key, { schema: value, source: sourceName });
-    }
-  }
-  if (resolved.allOf) {
-    for (const subSchema of resolved.allOf) {
-      const subProps = collectProperties(subSchema, context);
-      for (const [key, value] of subProps) {
-        if (!props.has(key)) {
-          props.set(key, value);
-        }
-      }
-    }
-  }
-  return props;
-}
-function schemasMatch(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-function detectConflictingProperties(schemas, context) {
-  const conflicts = [];
-  const propertyMap = /* @__PURE__ */ new Map();
-  for (const schema of schemas) {
-    const schemaProps = collectProperties(schema, context);
-    for (const [propName, propInfo] of schemaProps) {
-      const existing = propertyMap.get(propName);
-      if (existing) {
-        if (!schemasMatch(existing.schema, propInfo.schema)) {
-          conflicts.push(
-            `Property "${propName}" has conflicting definitions in ${existing.source} and ${propInfo.source}`
-          );
-        }
-      } else {
-        propertyMap.set(propName, propInfo);
-      }
-    }
-  }
-  return conflicts;
-}
-function generateAllOf(schemas, isNullable2, context, currentSchema) {
-  if (schemas.length === 1) {
-    const singleSchema = context.generatePropertySchema(schemas[0], currentSchema, false, true);
-    return wrapNullable(singleSchema, isNullable2);
-  }
-  const conflicts = detectConflictingProperties(schemas, context);
-  let conflictDescription = "";
-  if (conflicts.length > 0) {
-    for (const conflict of conflicts) {
-      console.warn(`[openapi-to-zod] Warning: allOf composition conflict - ${conflict}`);
-    }
-    conflictDescription = `allOf property conflicts detected: ${conflicts.join("; ")}`;
-  }
-  const allObjects = schemas.every((s) => s.type === "object" || s.properties || s.$ref || s.allOf);
-  let result;
-  if (allObjects) {
-    let merged = context.generatePropertySchema(schemas[0], currentSchema, false, true);
-    for (let i = 1; i < schemas.length; i++) {
-      const schema = schemas[i];
-      if (schema.$ref) {
-        const refSchema = context.generatePropertySchema(schema, currentSchema, false, true);
-        merged = `${merged}.extend(${refSchema}.shape)`;
-      } else if (context.generateInlineObjectShape && (schema.properties || schema.type === "object")) {
-        const inlineShape = context.generateInlineObjectShape(schema, currentSchema);
-        merged = `${merged}.extend(${inlineShape})`;
-      } else {
-        const schemaString = context.generatePropertySchema(schema, currentSchema, false, true);
-        merged = `${merged}.extend(${schemaString}.shape)`;
-      }
-    }
-    result = merged;
-  } else {
-    const schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
-    let merged = schemaStrings[0];
-    for (let i = 1; i < schemaStrings.length; i++) {
-      merged = `${merged}.and(${schemaStrings[i]})`;
-    }
-    result = merged;
-  }
-  if (conflictDescription) {
-    result = `${result}.describe("${conflictDescription}")`;
-  }
-  return wrapNullable(result, isNullable2);
-}
-
-// src/validators/number-validator.ts
-function generateNumberValidation(schema, isInt, useDescribe) {
-  let validation = isInt ? "z.number().int()" : "z.number()";
-  if (schema.minimum !== void 0) {
-    const isExclusive = schema.exclusiveMinimum === true;
-    validation += isExclusive ? `.gt(${schema.minimum})` : `.gte(${schema.minimum})`;
-  } else if (typeof schema.exclusiveMinimum === "number") {
-    validation += `.gt(${schema.exclusiveMinimum})`;
-  }
-  if (schema.maximum !== void 0) {
-    const isExclusive = schema.exclusiveMaximum === true;
-    validation += isExclusive ? `.lt(${schema.maximum})` : `.lte(${schema.maximum})`;
-  } else if (typeof schema.exclusiveMaximum === "number") {
-    validation += `.lt(${schema.exclusiveMaximum})`;
-  }
-  if (schema.multipleOf !== void 0) {
-    validation += `.multipleOf(${schema.multipleOf})`;
-  }
-  return addDescription(validation, schema.description, useDescribe);
-}
-
-// src/generators/jsdoc-generator.ts
-function generateJSDoc(schema, name, options = { includeDescriptions: true }) {
-  if (!schema || typeof schema !== "object") {
-    return "";
-  }
-  if (!options.includeDescriptions) {
-    if (schema.deprecated) {
-      return "/** @deprecated */\n";
-    }
-    return "";
-  }
-  if (!schema.description && !schema.title && !schema.deprecated && !schema.examples && schema.example === void 0) {
-    return "";
-  }
-  const parts = [];
-  if (schema.title && typeof schema.title === "string" && (!name || schema.title !== name)) {
-    const sanitizedTitle = escapeJSDoc(schema.title).replace(/@/g, "\\@");
-    parts.push(sanitizedTitle);
-  }
-  if (schema.description && typeof schema.description === "string") {
-    const sanitizedDesc = escapeJSDoc(schema.description).replace(/@/g, "\\@").replace(/\*\//g, "*\\/");
-    parts.push(sanitizedDesc);
-  }
-  if (schema.examples && Array.isArray(schema.examples) && schema.examples.length > 0) {
-    try {
-      const examplesStr = schema.examples.map((ex) => JSON.stringify(ex)).join(", ");
-      parts.push(`@example ${examplesStr}`);
-    } catch (error) {
-      console.warn("Warning: Could not serialize schema examples", error);
-    }
-  } else if (schema.example !== void 0) {
-    try {
-      parts.push(`@example ${JSON.stringify(schema.example)}`);
-    } catch (error) {
-      console.warn("Warning: Could not serialize schema example", error);
-    }
-  }
-  if (schema.deprecated) {
-    parts.push("@deprecated");
-  }
-  if (parts.length === 0) {
-    return "";
-  }
-  const fullComment = parts.join(" ");
-  return `/** ${fullComment} */
-`;
-}
-
-// src/validators/conditional-validator.ts
-function generatePropertyAccess(propName) {
-  const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-  return validIdentifier.test(propName) ? `obj.${propName}` : `obj["${propName}"]`;
-}
-function generateDependencies(schema, generatePropertySchema, currentSchema) {
-  if (!schema.dependencies) {
-    return "";
-  }
-  let result = "";
-  for (const [prop, dependency] of Object.entries(schema.dependencies)) {
-    if (Array.isArray(dependency)) {
-      if (dependency.length === 0) {
-        continue;
-      }
-      const propAccess = generatePropertyAccess(prop);
-      const checkLogic = dependency.map((p) => {
-        const pAccess = generatePropertyAccess(p);
-        return `if (${pAccess} === undefined) missing.push('${p}');`;
-      }).join("\n		");
-      result += `.superRefine((obj, ctx) => {
-				if (${propAccess} === undefined) return;
-				const missing: string[] = [];
-				${checkLogic}
-				if (missing.length > 0) {
-					ctx.addIssue({
-						code: "custom",
-						message: \`When '${prop}' is present, the following properties are required: \${missing.join(', ')}\`,
-						path: []
-					});
-				}
-			})`;
-    } else if (generatePropertySchema) {
-      const depSchema = { ...dependency, type: dependency.type || "object" };
-      const depSchemaValidation = generatePropertySchema(depSchema, currentSchema);
-      const propAccess = generatePropertyAccess(prop);
-      result += `.superRefine((obj, ctx) => {
-				if (${propAccess} === undefined) return;
-				const validation = ${depSchemaValidation}.safeParse(obj);
-				if (!validation.success) {
-					const errors = validation.error.issues.map(i => \`  - \${i.path.join('.')}: \${i.message}\`).join('\\n');
-					ctx.addIssue({
-						code: "custom",
-						message: \`When '${prop}' is present, object must satisfy additional constraints:\\n\${errors}\`,
-						path: []
-					});
-				}
-			})`;
-    }
-  }
-  return result;
-}
-function generateConditionalCheck(schema) {
-  const conditions = [];
-  if (schema.properties) {
-    for (const [prop, propSchema] of Object.entries(schema.properties)) {
-      const propAccess = generatePropertyAccess(prop);
-      if (propSchema.type) {
-        conditions.push(`typeof ${propAccess} === "${propSchema.type}"`);
-      }
-      if (propSchema.const !== void 0) {
-        const value = typeof propSchema.const === "string" ? `"${propSchema.const}"` : propSchema.const;
-        conditions.push(`${propAccess} === ${value}`);
-      }
-      if (propSchema.minimum !== void 0) {
-        conditions.push(`${propAccess} >= ${propSchema.minimum}`);
-      }
-      if (propSchema.maximum !== void 0) {
-        conditions.push(`${propAccess} <= ${propSchema.maximum}`);
-      }
-    }
-  }
-  if (schema.required) {
-    for (const prop of schema.required) {
-      conditions.push(`${generatePropertyAccess(prop)} !== undefined`);
-    }
-  }
-  return conditions.length > 0 ? conditions.join(" && ") : "true";
-}
-function generateConditionalValidation(schema) {
-  const checks = [];
-  if (schema.required) {
-    for (const prop of schema.required) {
-      checks.push(`${generatePropertyAccess(prop)} !== undefined`);
-    }
-  }
-  if (schema.properties) {
-    for (const [prop, propSchema] of Object.entries(schema.properties)) {
-      const propAccess = generatePropertyAccess(prop);
-      if (propSchema.minimum !== void 0) {
-        checks.push(`${propAccess} === undefined || ${propAccess} >= ${propSchema.minimum}`);
-      }
-      if (propSchema.maximum !== void 0) {
-        checks.push(`${propAccess} === undefined || ${propAccess} <= ${propSchema.maximum}`);
-      }
-    }
-  }
-  return checks.length > 0 ? checks.join(" && ") : "true";
-}
-function generateIfThenElse(schema) {
-  if (!schema.if || !schema.then && !schema.else) {
-    return "";
-  }
-  const ifCondition = generateConditionalCheck(schema.if);
-  if (schema.then && schema.else) {
-    const thenValidation = generateConditionalValidation(schema.then);
-    const elseValidation2 = generateConditionalValidation(schema.else);
-    const thenRequiredProps = schema.then.required || [];
-    const elseRequiredProps2 = schema.else.required || [];
-    return `.superRefine((obj, ctx) => {
-			const ifConditionMet = ${ifCondition};
-			if (ifConditionMet) {
-				// Then branch
-				const thenValid = ${thenValidation};
-				if (!thenValid) {
-					${thenRequiredProps.length > 0 ? `
-					const missingThenProps = ${JSON.stringify(thenRequiredProps)}.filter(p => obj[p] === undefined);
-					const message = missingThenProps.length > 0 
-						? \`When condition is met, required properties are missing: \${missingThenProps.join(', ')}\`
-						: "When condition is met, validation constraints failed";
-					` : `
-					const message = "When condition is met, validation constraints failed";
-					`}
-					ctx.addIssue({
-						code: "custom",
-						message: message,
-						path: []
-					});
-				}
-			} else {
-				// Else branch
-				const elseValid = ${elseValidation2};
-				if (!elseValid) {
-					${elseRequiredProps2.length > 0 ? `
-					const missingElseProps = ${JSON.stringify(elseRequiredProps2)}.filter(p => obj[p] === undefined);
-					const message = missingElseProps.length > 0 
-						? \`When condition is not met, required properties are missing: \${missingElseProps.join(', ')}\`
-						: "When condition is not met, validation constraints failed";
-					` : `
-					const message = "When condition is not met, validation constraints failed";
-					`}
-					ctx.addIssue({
-						code: "custom",
-						message: message,
-						path: []
-					});
-				}
-			}
-		})`;
-  }
-  if (schema.then) {
-    const thenValidation = generateConditionalValidation(schema.then);
-    const thenRequiredProps = schema.then.required || [];
-    return `.superRefine((obj, ctx) => {
-			const ifConditionMet = ${ifCondition};
-			if (ifConditionMet) {
-				const thenValid = ${thenValidation};
-				if (!thenValid) {
-					${thenRequiredProps.length > 0 ? `
-					const missingProps = ${JSON.stringify(thenRequiredProps)}.filter(p => obj[p] === undefined);
-					const message = missingProps.length > 0 
-						? \`When condition is met, required properties are missing: \${missingProps.join(', ')}\`
-						: "When condition is met, validation constraints failed";
-					` : `
-					const message = "When condition is met, validation constraints failed";
-					`}
-					ctx.addIssue({
-						code: "custom",
-						message: message,
-						path: []
-					});
-				}
-			}
-		})`;
-  }
-  if (!schema.else) return "";
-  const elseValidation = generateConditionalValidation(schema.else);
-  const elseRequiredProps = schema.else.required || [];
-  return `.superRefine((obj, ctx) => {
-		const ifConditionMet = ${ifCondition};
-		if (!ifConditionMet) {
-			const elseValid = ${elseValidation};
-			if (!elseValid) {
-				${elseRequiredProps.length > 0 ? `
-				const missingProps = ${JSON.stringify(elseRequiredProps)}.filter(p => obj[p] === undefined);
-				const message = missingProps.length > 0 
-					? \`When condition is not met, required properties are missing: \${missingProps.join(', ')}\`
-					: "When condition is not met, validation constraints failed";
-				` : `
-				const message = "When condition is not met, validation constraints failed";
-				`}
-				ctx.addIssue({
-					code: "custom",
-					message: message,
-					path: []
-				});
-			}
-		}
-	})`;
-}
-function generateDependentRequired(schema) {
-  if (!schema.dependentRequired) {
-    return "";
-  }
-  let result = "";
-  for (const [prop, requiredProps] of Object.entries(schema.dependentRequired)) {
-    if (requiredProps.length === 0) {
-      continue;
-    }
-    const propAccess = generatePropertyAccess(prop);
-    const checkLogic = requiredProps.map((rp) => {
-      const rpAccess = generatePropertyAccess(rp);
-      return `if (${rpAccess} === undefined) missing.push('${rp}');`;
-    }).join("\n		");
-    result += `.superRefine((obj, ctx) => {
-			if (${propAccess} === undefined) return;
-			const missing: string[] = [];
-			${checkLogic}
-			if (missing.length > 0) {
-				ctx.addIssue({
-					code: "custom",
-					message: \`When '${prop}' is present, the following properties are required: \${missing.join(', ')}\`,
-					path: []
-				});
-			}
-		})`;
-  }
-  return result;
-}
-
-// src/validators/object-validator.ts
-function needsQuoting(propName) {
-  const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-  return !validIdentifier.test(propName);
-}
-function generatePropertyAccess2(propName) {
-  return needsQuoting(propName) ? `obj["${propName}"]` : `obj.${propName}`;
-}
-function generateObjectSchema(schema, context, currentSchema) {
-  const required = new Set(schema.required || []);
-  const properties = [];
-  if (schema.properties) {
-    for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      if (!context.shouldIncludeProperty(propSchema)) {
-        continue;
-      }
-      const isRequired = required.has(propName);
-      const zodSchema = context.generatePropertySchema(propSchema, currentSchema);
-      const quotedPropName = needsQuoting(propName) ? `"${propName}"` : propName;
-      let propertyDef = `  ${quotedPropName}: ${zodSchema}`;
-      if (!isRequired) {
-        propertyDef += ".optional()";
-      }
-      const jsdoc = generateJSDoc(propSchema, propName, { includeDescriptions: context.includeDescriptions });
-      if (jsdoc) {
-        properties.push(`${jsdoc.trimEnd()}
-${propertyDef}`);
-      } else {
-        properties.push(propertyDef);
-      }
-    }
-  }
-  let objectMethod;
-  if (schema.additionalProperties === false) {
-    objectMethod = "z.strictObject";
-  } else {
-    switch (context.mode) {
-      case "strict":
-        objectMethod = "z.strictObject";
-        break;
-      case "loose":
-        objectMethod = "z.looseObject";
-        break;
-      default:
-        objectMethod = "z.object";
-    }
-  }
-  let objectDef = `${objectMethod}({
-${properties.join(",\n")}
-})`;
-  if (schema.additionalProperties !== void 0) {
-    if (typeof schema.additionalProperties === "object") {
-      const additionalSchema = context.generatePropertySchema(schema.additionalProperties, currentSchema);
-      objectDef += `.catchall(${additionalSchema})`;
-    } else if (schema.additionalProperties === true) {
-      objectDef += ".catchall(z.unknown())";
-    }
-  } else if (schema.patternProperties) {
-    objectDef += ".catchall(z.unknown())";
-  }
-  if (schema.minProperties !== void 0 || schema.maxProperties !== void 0) {
-    const conditions = [];
-    if (schema.minProperties !== void 0) {
-      conditions.push(`Object.keys(obj).length >= ${schema.minProperties}`);
-    }
-    if (schema.maxProperties !== void 0) {
-      conditions.push(`Object.keys(obj).length <= ${schema.maxProperties}`);
-    }
-    const condition = conditions.join(" && ");
-    let message = "Object ";
-    if (schema.minProperties !== void 0 && schema.maxProperties !== void 0) {
-      message += `must have between ${schema.minProperties} and ${schema.maxProperties} properties`;
-    } else if (schema.minProperties !== void 0) {
-      message += `must have at least ${schema.minProperties} ${schema.minProperties === 1 ? "property" : "properties"}`;
-    } else {
-      message += `must have at most ${schema.maxProperties} ${schema.maxProperties === 1 ? "property" : "properties"}`;
-    }
-    objectDef += `.refine((obj) => ${condition}, { message: "${message}" })`;
-  }
-  const definedProps = new Set(Object.keys(schema.properties || {}));
-  const undefinedRequired = (schema.required || []).filter((prop) => !definedProps.has(prop));
-  if (undefinedRequired.length > 0) {
-    if (!objectDef.includes(".catchall(")) {
-      objectDef += ".catchall(z.unknown())";
-    }
-    const requiredChecks = undefinedRequired.map((prop) => `${generatePropertyAccess2(prop)} !== undefined`).join(" && ");
-    const propList = undefinedRequired.join(", ");
-    objectDef += `.refine((obj) => ${requiredChecks}, { message: "Missing required fields: ${propList}" })`;
-  }
-  if (schema.patternProperties) {
-    const definedProps2 = Object.keys(schema.properties || {});
-    const definedPropsSet = `new Set(${JSON.stringify(definedProps2)})`;
-    const patterns = Object.entries(schema.patternProperties);
-    const patternSchemas = patterns.map(([pattern, patternSchema]) => ({
-      pattern,
-      escapedPattern: pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'"),
-      zodSchema: context.generatePropertySchema(patternSchema, currentSchema)
-    }));
-    objectDef += `.superRefine((obj, ctx) => {
-			const definedPropsSet = ${definedPropsSet};
-			const patterns = ${JSON.stringify(patternSchemas.map((p) => ({ pattern: p.escapedPattern })))};
-			const schemas = [${patternSchemas.map((p) => p.zodSchema).join(", ")}];
-			const regexps = patterns.map(p => new RegExp(p.pattern));
-
-			// Check all object keys
-			for (const key of Object.keys(obj)) {
-				// Skip properties that are explicitly defined
-				if (definedPropsSet.has(key)) continue;
-
-				// Find first matching pattern (first-match-wins priority)
-				for (let i = 0; i < regexps.length; i++) {
-					if (regexps[i].test(key)) {
-						const validation = schemas[i].safeParse(obj[key]);
-						if (!validation.success) {
-							// Add detailed error messages with property name and pattern
-							for (const issue of validation.error.issues) {
-								ctx.addIssue({
-									...issue,
-									path: [key, ...issue.path],
-									message: \`Property '\${key}' (pattern '\${patterns[i].pattern}'): \${issue.message}\`
-								});
-							}
-						}
-						break; // First match wins, stop checking other patterns
-					}
-				}
-			}
-		})`;
-  }
-  if (schema.propertyNames) {
-    const hasPattern = schema.propertyNames.pattern !== void 0;
-    const hasMinLength = schema.propertyNames.minLength !== void 0;
-    const hasMaxLength = schema.propertyNames.maxLength !== void 0;
-    if (hasPattern || hasMinLength || hasMaxLength) {
-      const escapedPattern = hasPattern && schema.propertyNames.pattern ? schema.propertyNames.pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'") : null;
-      const minLen = schema.propertyNames.minLength;
-      const maxLen = schema.propertyNames.maxLength;
-      objectDef += `.superRefine((obj, ctx) => {
-				${escapedPattern ? `const pattern = /${escapedPattern}/;` : ""}
-
-				for (const key of Object.keys(obj)) {
-					const failures: string[] = [];
-
-					${hasPattern ? `
-					if (!pattern.test(key)) {
-						failures.push("must match pattern '${schema.propertyNames.pattern}'");
-					}
-					` : ""}
-
-					${hasMinLength ? `
-					if (key.length < ${minLen}) {
-						failures.push("must be at least ${minLen} characters");
-					}
-					` : ""}
-
-					${hasMaxLength ? `
-					if (key.length > ${maxLen}) {
-						failures.push("must be at most ${maxLen} characters");
-					}
-					` : ""}
-
-					if (failures.length > 0) {
-						ctx.addIssue({
-							code: "custom",
-							message: \`Property name '\${key}' \${failures.join(", ")}\`,
-							path: [key]
-						});
-					}
-				}
-			})`;
-    }
-  }
-  objectDef += generateDependencies(schema, context.generatePropertySchema, currentSchema);
-  objectDef += generateDependentRequired(schema);
-  objectDef += generateIfThenElse(schema);
-  return objectDef;
-}
-
-// src/validators/string-validator.ts
-var DEFAULT_FORMAT_MAP = {
-  uuid: "z.uuid()",
-  email: "z.email()",
-  uri: "z.url()",
-  url: "z.url()",
-  "uri-reference": 'z.string().refine((val) => !/\\s/.test(val), { message: "Must be a valid URI reference" })',
-  hostname: 'z.string().refine((val) => /^(?=.{1,253}$)(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\\.)*(?!-)[A-Za-z0-9-]{1,63}(?<!-)$/.test(val), { message: "Must be a valid hostname" })',
-  byte: "z.base64()",
-  binary: "z.string()",
-  date: "z.iso.date()",
-  time: "z.iso.time()",
-  duration: 'z.string().refine((val) => /^P(?:(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?|\\d+W)$/.test(val) && !/^PT?$/.test(val), { message: "Must be a valid ISO 8601 duration" })',
-  ipv4: "z.ipv4()",
-  ipv6: "z.ipv6()",
-  emoji: "z.emoji()",
-  base64: "z.base64()",
-  base64url: "z.base64url()",
-  nanoid: "z.nanoid()",
-  cuid: "z.cuid()",
-  cuid2: "z.cuid2()",
-  ulid: "z.ulid()",
-  cidr: "z.cidrv4()",
-  // Default to v4
-  cidrv4: "z.cidrv4()",
-  cidrv6: "z.cidrv6()",
-  "json-pointer": 'z.string().refine((val) => val === "" || /^(\\/([^~/]|~0|~1)+)+$/.test(val), { message: "Must be a valid JSON Pointer (RFC 6901)" })',
-  "relative-json-pointer": 'z.string().refine((val) => /^(0|[1-9]\\d*)(#|(\\/([^~/]|~0|~1)+)*)$/.test(val), { message: "Must be a valid relative JSON Pointer" })'
-};
-function buildDateTimeValidation(pattern) {
-  if (!pattern) {
-    return "z.iso.datetime()";
-  }
-  const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
-  if (patternStr === "") {
-    return "z.iso.datetime()";
-  }
-  try {
-    new RegExp(patternStr);
-  } catch (error) {
-    throw new Error(
-      `Invalid regular expression pattern for customDateTimeFormatRegex: ${patternStr}. ${error instanceof Error ? error.message : "Pattern is malformed"}`
-    );
-  }
-  const escapedPattern = escapePattern(patternStr);
-  return `z.string().regex(/${escapedPattern}/)`;
-}
-function generateStringValidation(schema, useDescribe, context) {
-  let validation;
-  const format = schema.format || "";
-  if (format === "date-time") {
-    validation = context.dateTimeValidation;
-  } else {
-    validation = DEFAULT_FORMAT_MAP[format] || "z.string()";
-  }
-  if (schema.minLength !== void 0) {
-    validation += `.min(${schema.minLength})`;
-  }
-  if (schema.maxLength !== void 0) {
-    validation += `.max(${schema.maxLength})`;
-  }
-  if (schema.pattern) {
-    let escapedPattern = context.patternCache.get(schema.pattern);
-    if (escapedPattern === void 0) {
-      escapedPattern = escapePattern(schema.pattern);
-      context.patternCache.set(schema.pattern, escapedPattern);
-    }
-    validation += `.regex(/${escapedPattern}/)`;
-  }
-  if (schema.contentEncoding && !schema.format) {
-    switch (schema.contentEncoding) {
-      case "base64":
-        validation = "z.base64()";
-        break;
-      case "base64url":
-        validation = "z.base64url()";
-        break;
-      case "quoted-printable":
-        validation = 'z.string().refine((val) => /^[\\x20-\\x7E\\r\\n=]*$/.test(val), { message: "Must be valid quoted-printable encoding" })';
-        break;
-      case "7bit":
-      case "8bit":
-      case "binary":
-        validation = "z.string()";
-        break;
-      default:
-        validation = `z.string().describe("Content encoding: ${schema.contentEncoding}")`;
-    }
-    if (schema.minLength !== void 0) {
-      validation += `.min(${schema.minLength})`;
-    }
-    if (schema.maxLength !== void 0) {
-      validation += `.max(${schema.maxLength})`;
-    }
-    if (schema.pattern) {
-      let escapedPattern = context.patternCache.get(schema.pattern);
-      if (escapedPattern === void 0) {
-        escapedPattern = escapePattern(schema.pattern);
-        context.patternCache.set(schema.pattern, escapedPattern);
-      }
-      validation += `.regex(/${escapedPattern}/)`;
-    }
-  } else if (schema.contentMediaType) {
-    const mediaType = schema.contentMediaType;
-    if (mediaType === "application/json") {
-      validation += `.refine((val) => { try { JSON.parse(val); return true; } catch { return false; } }, { message: "Must be valid JSON" })`;
-    } else if (mediaType === "application/xml" || mediaType === "text/xml") {
-      validation += `.refine((val) => { try { if (typeof DOMParser !== "undefined") { const parser = new DOMParser(); const doc = parser.parseFromString(val, "text/xml"); return !doc.querySelector("parsererror"); } return /^\\s*<[^>]+>/.test(val); } catch { return false; } }, { message: "Must be valid XML" })`;
-    } else if (mediaType === "application/yaml" || mediaType === "application/x-yaml" || mediaType === "text/yaml") {
-      validation += `.refine((val) => { try { return val.trim().length > 0 && !/^[[{]/.test(val.trim()); } catch { return false; } }, { message: "Must be valid YAML" })`;
-    } else if (mediaType === "text/html") {
-      validation += `.refine((val) => /<[^>]+>/.test(val), { message: "Must contain HTML tags" })`;
-    } else if (mediaType === "text/plain") {
-      validation += `.refine(() => true, { message: "Plain text content" })`;
-    }
-  }
-  return addDescription(validation, schema.description, useDescribe);
-}
-
-// src/generators/property-generator.ts
-var _PropertyGenerator = class _PropertyGenerator {
-  constructor(context) {
-    // Performance optimization: Memoize filtered property results
-    this.filteredPropsCache = /* @__PURE__ */ new Map();
-    // Performance optimization: LRU cache for generated schemas
-    this.schemaCache = new LRUCache(500);
-    this.context = context;
-  }
-  /**
-   * Check if a property should be included based on schemaType and readOnly/writeOnly flags
-   */
-  shouldIncludeProperty(schema) {
-    const rule = _PropertyGenerator.INCLUSION_RULES[this.context.schemaType];
-    return rule(schema);
-  }
-  /**
-   * Recursively filter any schema type (helper for composition schemas)
-   */
-  filterSchemaRecursive(schema) {
-    if (schema.$ref) {
-      return schema;
-    }
-    if (schema.properties) {
-      return this.filterNestedProperties(schema);
-    }
-    if (schema.type === "array" && schema.items && typeof schema.items === "object" && schema.items.properties) {
-      return {
-        ...schema,
-        items: this.filterNestedProperties(schema.items)
-      };
-    }
-    return schema;
-  }
-  /**
-   * Recursively filter properties in nested objects based on readOnly/writeOnly
-   * Performance optimized with memoization
-   */
-  filterNestedProperties(schema) {
-    var _a, _b;
-    const propKeys = schema.properties ? Object.keys(schema.properties).sort().join(",") : "";
-    const cacheKey = `${this.context.schemaType}:${schema.type || "unknown"}:${propKeys}:${((_a = schema.required) == null ? void 0 : _a.join(",")) || ""}`;
-    const cached = this.filteredPropsCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    if (!schema.properties) {
-      return schema;
-    }
-    const filteredProperties = {};
-    const filteredRequired = [];
-    for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      if (!this.shouldIncludeProperty(propSchema)) {
-        continue;
-      }
-      let filteredPropSchema = propSchema;
-      if (propSchema.type === "object" && propSchema.properties) {
-        filteredPropSchema = this.filterNestedProperties(propSchema);
-      } else if (propSchema.type === "array" && propSchema.items && typeof propSchema.items === "object" && propSchema.items.properties) {
-        filteredPropSchema = {
-          ...propSchema,
-          items: this.filterNestedProperties(propSchema.items)
-        };
-      } else if (propSchema.allOf || propSchema.oneOf || propSchema.anyOf) {
-        if (propSchema.allOf) {
-          filteredPropSchema = {
-            ...propSchema,
-            allOf: propSchema.allOf.map((s) => this.filterSchemaRecursive(s))
-          };
-        } else if (propSchema.oneOf) {
-          filteredPropSchema = {
-            ...propSchema,
-            oneOf: propSchema.oneOf.map((s) => this.filterSchemaRecursive(s))
-          };
-        } else if (propSchema.anyOf) {
-          filteredPropSchema = {
-            ...propSchema,
-            anyOf: propSchema.anyOf.map((s) => this.filterSchemaRecursive(s))
-          };
-        }
-      }
-      filteredProperties[propName] = filteredPropSchema;
-      if ((_b = schema.required) == null ? void 0 : _b.includes(propName)) {
-        filteredRequired.push(propName);
-      }
-    }
-    const result = {
-      ...schema,
-      properties: filteredProperties,
-      required: filteredRequired.length > 0 ? filteredRequired : void 0
-    };
-    this.filteredPropsCache.set(cacheKey, result);
-    return result;
-  }
-  /**
-   * Resolve discriminator mapping to actual schema references
-   */
-  resolveDiscriminatorMapping(mapping, schemas) {
-    const mappedSchemas = [];
-    for (const [_, schemaRef] of Object.entries(mapping)) {
-      const matchingSchema = schemas.find((s) => {
-        if (s.$ref) {
-          return s.$ref === schemaRef || s.$ref.endsWith(schemaRef);
-        }
-        return false;
-      });
-      if (matchingSchema) {
-        mappedSchemas.push(matchingSchema);
-      } else {
-        mappedSchemas.push({ $ref: schemaRef });
-      }
-    }
-    for (const schema of schemas) {
-      if (!mappedSchemas.includes(schema)) {
-        mappedSchemas.push(schema);
-      }
-    }
-    return mappedSchemas;
-  }
-  /**
-   * Resolve a $ref string to the actual schema
-   */
-  resolveSchemaRef(ref) {
-    var _a, _b;
-    const schemaName = ref.split("/").pop();
-    if (!schemaName) return void 0;
-    return (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[schemaName];
-  }
-  /**
-   * Resolve a schema name through any aliases to get the actual schema name
-   * If the schema is an alias (allOf with single $ref), return the target name
-   */
-  resolveSchemaAlias(schemaName) {
-    var _a, _b;
-    const schema = (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[schemaName];
-    if (!schema) return schemaName;
-    if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref && !schema.properties && !schema.oneOf && !schema.anyOf) {
-      const targetName = resolveRef(schema.allOf[0].$ref);
-      return this.resolveSchemaAlias(targetName);
-    }
-    return schemaName;
-  }
-  /**
-   * Check if this is a circular dependency through aliases
-   */
-  isCircularThroughAlias(fromSchema, toSchema) {
-    var _a, _b;
-    const toSchemaSpec = (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[toSchema];
-    if (!toSchemaSpec) return false;
-    if (toSchemaSpec.allOf && toSchemaSpec.allOf.length === 1 && toSchemaSpec.allOf[0].$ref) {
-      const aliasTarget = resolveRef(toSchemaSpec.allOf[0].$ref);
-      return aliasTarget === fromSchema;
-    }
-    return false;
-  }
-  /**
-   * Generate union for multiple types (OpenAPI 3.1)
-   */
-  generateMultiTypeUnion(schema, currentSchema) {
-    if (!Array.isArray(schema.type)) {
-      return "z.unknown()";
-    }
-    const nonNullTypes = schema.type.filter((t) => t !== "null");
-    const schemas = nonNullTypes.map((type) => {
-      const typeSchema = { ...schema, type };
-      return this.generatePropertySchema(typeSchema, currentSchema);
-    });
-    return `z.union([${schemas.join(", ")}])`;
-  }
-  /**
-   * Apply unevaluatedProperties validation to a schema
-   */
-  applyUnevaluatedProperties(baseSchema, schema) {
-    const evaluatedProps = /* @__PURE__ */ new Set();
-    if (schema.properties) {
-      for (const propName of Object.keys(schema.properties)) {
-        evaluatedProps.add(propName);
-      }
-    }
-    const collectPropsFromComposition = (schemas) => {
-      var _a, _b;
-      if (!schemas) return;
-      for (const subSchema of schemas) {
-        if (subSchema.properties) {
-          for (const propName of Object.keys(subSchema.properties)) {
-            evaluatedProps.add(propName);
-          }
-        }
-        if (subSchema.$ref) {
-          const refSchema = (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[subSchema.$ref.split("/").pop() || ""];
-          if (refSchema == null ? void 0 : refSchema.properties) {
-            for (const propName of Object.keys(refSchema.properties)) {
-              evaluatedProps.add(propName);
-            }
-          }
-        }
-      }
-    };
-    collectPropsFromComposition(schema.allOf);
-    collectPropsFromComposition(schema.oneOf);
-    collectPropsFromComposition(schema.anyOf);
-    const evaluatedPropsSet = `new Set(${JSON.stringify([...evaluatedProps])})`;
-    let schemaWithCatchall = baseSchema;
-    if (baseSchema.includes(".union([") || baseSchema.includes(".discriminatedUnion(")) {
-      schemaWithCatchall = baseSchema;
-    } else if (baseSchema.includes(".extend(")) {
-      schemaWithCatchall = `${baseSchema}.catchall(z.unknown())`;
-    }
-    if (schema.unevaluatedProperties === false) {
-      return `${schemaWithCatchall}.refine((obj) => Object.keys(obj).every(key => ${evaluatedPropsSet}.has(key)), { message: "No unevaluated properties allowed" })`;
-    } else if (typeof schema.unevaluatedProperties === "object") {
-      const unevalSchema = this.generatePropertySchema(schema.unevaluatedProperties);
-      return `${schemaWithCatchall}.refine((obj) => Object.keys(obj).filter(key => !${evaluatedPropsSet}.has(key)).every(key => ${unevalSchema}.safeParse(obj[key]).success), { message: "Unevaluated properties must match the schema" })`;
-    }
-    return baseSchema;
-  }
-  /**
-   * Generate Zod schema for a property
-   * @param schema - The OpenAPI schema to generate
-   * @param currentSchema - The name of the current schema being processed (for circular ref detection)
-   * @param isTopLevel - Whether this is a top-level schema definition
-   * @param suppressDefaultNullable - When true, don't apply defaultNullable (used when outer schema has explicit nullable: false)
-   */
-  generatePropertySchema(schema, currentSchema, isTopLevel = false, suppressDefaultNullable = false) {
-    var _a, _b, _c, _d, _e;
-    const isCacheable = !schema.$ref && !schema.allOf && !schema.oneOf && !schema.anyOf && !currentSchema;
-    if (isCacheable) {
-      const cacheKey = JSON.stringify({
-        schema,
-        type: this.context.schemaType,
-        mode: this.context.mode,
-        suppressDefaultNullable
-      });
-      const cached = this.schemaCache.get(cacheKey);
-      if (cached) {
-        return cached;
-      }
-    }
-    if ((this.context.schemaType === "request" || this.context.schemaType === "response") && schema.properties) {
-      schema = this.filterNestedProperties(schema);
-    }
-    const isEnum = !!schema.enum;
-    const isConst = schema.const !== void 0;
-    const shouldApplyDefaultNullable = !isTopLevel && !isEnum && !isConst && !suppressDefaultNullable;
-    const effectiveDefaultNullable = shouldApplyDefaultNullable ? this.context.defaultNullable : false;
-    const nullable = isNullable(schema, effectiveDefaultNullable);
-    if (hasMultipleTypes(schema)) {
-      const union = this.generateMultiTypeUnion(schema, currentSchema);
-      return wrapNullable(union, nullable);
-    }
-    if (schema.$ref) {
-      const refName = resolveRef(schema.$ref);
-      const resolvedRefName = this.resolveSchemaAlias(refName);
-      if (currentSchema && refName !== currentSchema && !isTopLevel) {
-        if (!this.context.schemaDependencies.has(currentSchema)) {
-          this.context.schemaDependencies.set(currentSchema, /* @__PURE__ */ new Set());
-        }
-        (_a = this.context.schemaDependencies.get(currentSchema)) == null ? void 0 : _a.add(refName);
-      }
-      const strippedRefName = stripPrefix(resolvedRefName, this.context.stripSchemaPrefix);
-      const schemaName = `${toCamelCase(strippedRefName, this.context.namingOptions)}Schema`;
-      if (currentSchema && (refName === currentSchema || this.isCircularThroughAlias(currentSchema, refName))) {
-        const lazySchema = `z.lazy((): z.ZodTypeAny => ${schemaName})`;
-        return wrapNullable(lazySchema, nullable);
-      }
-      return wrapNullable(schemaName, nullable);
-    }
-    if (schema.const !== void 0) {
-      const literalValue = typeof schema.const === "string" ? `"${schema.const}"` : schema.const;
-      const zodLiteral = `z.literal(${literalValue})`;
-      return wrapNullable(zodLiteral, nullable);
-    }
-    if (schema.enum) {
-      const allBooleans = schema.enum.every((v) => typeof v === "boolean");
-      if (allBooleans) {
-        const zodBoolean = "z.boolean()";
-        return wrapNullable(zodBoolean, nullable);
-      }
-      const allStrings = schema.enum.every((v) => typeof v === "string");
-      if (allStrings) {
-        const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
-        const zodEnum = `z.enum([${enumValues}])`;
-        return wrapNullable(zodEnum, nullable);
-      }
-      const literalValues = schema.enum.map((v) => {
-        if (typeof v === "string") {
-          return `z.literal("${v}")`;
-        }
-        return `z.literal(${v})`;
-      }).join(", ");
-      const zodUnion = `z.union([${literalValues}])`;
-      return wrapNullable(zodUnion, nullable);
-    }
-    if (schema.allOf) {
-      const compositionNullable = isNullable(schema, false);
-      let composition = generateAllOf(
-        schema.allOf,
-        compositionNullable,
-        {
-          generatePropertySchema: this.generatePropertySchema.bind(this),
-          generateInlineObjectShape: this.generateInlineObjectShape.bind(this),
-          resolveSchemaRef: this.resolveSchemaRef.bind(this)
-        },
-        currentSchema
-      );
-      if (schema.unevaluatedProperties !== void 0) {
-        composition = this.applyUnevaluatedProperties(composition, schema);
-      }
-      return composition;
-    }
-    if (schema.oneOf) {
-      const compositionNullable = isNullable(schema, false);
-      const needsPassthrough = schema.unevaluatedProperties !== void 0;
-      let composition = generateUnion(
-        schema.oneOf,
-        (_b = schema.discriminator) == null ? void 0 : _b.propertyName,
-        compositionNullable,
-        {
-          generatePropertySchema: this.generatePropertySchema.bind(this),
-          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
-          resolveSchemaRef: this.resolveSchemaRef.bind(this)
-        },
-        {
-          passthrough: needsPassthrough,
-          discriminatorMapping: (_c = schema.discriminator) == null ? void 0 : _c.mapping
-        },
-        currentSchema
-      );
-      if (schema.unevaluatedProperties !== void 0) {
-        composition = this.applyUnevaluatedProperties(composition, schema);
-      }
-      return composition;
-    }
-    if (schema.anyOf) {
-      const compositionNullable = isNullable(schema, false);
-      const needsPassthrough = schema.unevaluatedProperties !== void 0;
-      let composition = generateUnion(
-        schema.anyOf,
-        (_d = schema.discriminator) == null ? void 0 : _d.propertyName,
-        compositionNullable,
-        {
-          generatePropertySchema: this.generatePropertySchema.bind(this),
-          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
-          resolveSchemaRef: this.resolveSchemaRef.bind(this)
-        },
-        {
-          passthrough: needsPassthrough,
-          discriminatorMapping: (_e = schema.discriminator) == null ? void 0 : _e.mapping
-        },
-        currentSchema
-      );
-      if (schema.unevaluatedProperties !== void 0) {
-        composition = this.applyUnevaluatedProperties(composition, schema);
-      }
-      return composition;
-    }
-    if (schema.not) {
-      const notSchema = this.generatePropertySchema(schema.not, currentSchema);
-      let baseValidation;
-      if (schema.type || schema.properties || schema.items) {
-        const { not: _, ...baseSchema } = schema;
-        baseValidation = this.generatePropertySchema(baseSchema, currentSchema);
-      } else {
-        baseValidation = "z.unknown()";
-      }
-      const refined = `${baseValidation}.refine((val) => !${notSchema}.safeParse(val).success, { message: "Value must not match the excluded schema" })`;
-      return wrapNullable(refined, nullable);
-    }
-    let validation = "";
-    const primaryType = getPrimaryType(schema);
-    switch (primaryType) {
-      case "string":
-        validation = generateStringValidation(schema, this.context.useDescribe, {
-          dateTimeValidation: this.context.dateTimeValidation,
-          patternCache: this.context.patternCache
-        });
-        break;
-      case "number":
-        validation = generateNumberValidation(schema, false, this.context.useDescribe);
-        break;
-      case "integer":
-        validation = generateNumberValidation(schema, true, this.context.useDescribe);
-        break;
-      case "boolean":
-        validation = "z.boolean()";
-        validation = addDescription(validation, schema.description, this.context.useDescribe);
-        break;
-      case "array":
-        validation = generateArrayValidation(schema, {
-          generatePropertySchema: this.generatePropertySchema.bind(this),
-          useDescribe: this.context.useDescribe,
-          currentSchema
-        });
-        break;
-      case "object":
-        if (schema.properties || schema.required || schema.minProperties !== void 0 || schema.maxProperties !== void 0 || schema.patternProperties || schema.propertyNames) {
-          validation = generateObjectSchema(
-            schema,
-            {
-              generatePropertySchema: this.generatePropertySchema.bind(this),
-              shouldIncludeProperty: this.shouldIncludeProperty.bind(this),
-              mode: this.context.mode,
-              includeDescriptions: this.context.includeDescriptions,
-              useDescribe: this.context.useDescribe
-            },
-            currentSchema
-          );
-          validation = addDescription(validation, schema.description, this.context.useDescribe);
-        } else {
-          switch (this.context.emptyObjectBehavior) {
-            case "strict":
-              validation = "z.strictObject({})";
-              break;
-            case "loose":
-              validation = "z.looseObject({})";
-              break;
-            default:
-              validation = "z.record(z.string(), z.unknown())";
-              break;
-          }
-          validation = addDescription(validation, schema.description, this.context.useDescribe);
-        }
-        break;
-      default:
-        validation = "z.unknown()";
-        validation = addDescription(validation, schema.description, this.context.useDescribe);
-    }
-    const result = wrapNullable(validation, nullable);
-    if (isCacheable) {
-      const cacheKey = JSON.stringify({ schema, type: this.context.schemaType, mode: this.context.mode });
-      this.schemaCache.set(cacheKey, result);
-    }
-    return result;
-  }
-  /**
-   * Generate inline object shape for use with .extend()
-   * Returns just the shape object literal: { prop1: z.string(), prop2: z.number() }
-   *
-   * This method is specifically for allOf compositions where we need to pass
-   * the shape directly to .extend() instead of using z.object({...}).shape.
-   * This avoids the .nullable().shape bug when inline objects have nullable: true.
-   *
-   * According to Zod docs (https://zod.dev/api?id=extend):
-   * - .extend() accepts an object of shape definitions
-   * - e.g., baseSchema.extend({ prop: z.string() })
-   */
-  generateInlineObjectShape(schema, currentSchema) {
-    const required = new Set(schema.required || []);
-    const properties = [];
-    if (schema.properties) {
-      for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        if (!this.shouldIncludeProperty(propSchema)) {
-          continue;
-        }
-        const isRequired = required.has(propName);
-        const zodSchema = this.generatePropertySchema(propSchema, currentSchema);
-        const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-        const quotedPropName = validIdentifier.test(propName) ? propName : `"${propName}"`;
-        let propertyDef = `${quotedPropName}: ${zodSchema}`;
-        if (!isRequired) {
-          propertyDef += ".optional()";
-        }
-        properties.push(propertyDef);
-      }
-    }
-    if (properties.length === 0) {
-      return "{}";
-    }
-    return `{
-${properties.map((p) => `	${p}`).join(",\n")}
-}`;
-  }
-};
-// Performance optimization: Lookup table for faster inclusion checks
-_PropertyGenerator.INCLUSION_RULES = {
-  request: (schema) => !schema.readOnly,
-  response: (schema) => !schema.writeOnly,
-  all: () => true
-};
-var PropertyGenerator = _PropertyGenerator;
-
-// src/utils/config-schemas.ts
-var import_zod = require("zod");
-var RequestResponseOptionsSchema = import_zod.z.strictObject({
-  mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
-  useDescribe: import_zod.z.boolean().optional(),
-  includeDescriptions: import_zod.z.boolean().optional(),
-  defaultNullable: import_zod.z.boolean().optional(),
-  emptyObjectBehavior: import_zod.z.enum(["strict", "loose", "record"]).optional()
-});
-var OperationFiltersSchema = import_zod.z.strictObject({
-  includeTags: import_zod.z.array(import_zod.z.string()).optional(),
-  excludeTags: import_zod.z.array(import_zod.z.string()).optional(),
-  includePaths: import_zod.z.array(import_zod.z.string()).optional(),
-  excludePaths: import_zod.z.array(import_zod.z.string()).optional(),
-  includeMethods: import_zod.z.array(import_zod.z.string()).optional(),
-  excludeMethods: import_zod.z.array(import_zod.z.string()).optional(),
-  includeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
-  excludeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
-  excludeDeprecated: import_zod.z.boolean().optional()
-});
-
-// src/utils/config-validation.ts
-function formatConfigValidationError(error, filepath, configPath, additionalNotes) {
-  var _a;
-  const formattedErrors = ((_a = error.issues) == null ? void 0 : _a.map((err) => {
-    const path = err.path.length > 0 ? err.path.join(".") : "root";
-    return `  - ${path}: ${err.message}`;
-  }).join("\n")) || "Unknown validation error";
-  const configSource = filepath || configPath || "config file";
-  const lines = [
-    `Invalid configuration file at: ${configSource}`,
-    "",
-    "Validation errors:",
-    formattedErrors,
-    "",
-    "Please check your configuration file and ensure:",
-    "  - All required fields are present (specs array with input/output)",
-    "  - Field names are spelled correctly (no typos)",
-    "  - Values match the expected types (e.g., mode: 'strict' | 'normal' | 'loose')",
-    "  - No unknown/extra properties are included"
-  ];
-  if (additionalNotes && additionalNotes.length > 0) {
-    lines.push(...additionalNotes.map((note) => `  - ${note}`));
-  }
-  return lines.join("\n");
-}
-
-// src/utils/content-type-utils.ts
-function getResponseParseMethod(contentType, fallback = "text") {
-  if (!contentType) {
-    return { method: fallback, isUnknown: true };
-  }
-  const normalized = contentType.toLowerCase().split(";")[0].trim();
-  if (!normalized) {
-    return { method: fallback, isUnknown: true };
-  }
-  if (normalized === "application/json" || normalized === "text/json" || normalized.endsWith("+json")) {
-    return { method: "json", isUnknown: false };
-  }
-  if (normalized.startsWith("text/")) {
-    return { method: "text", isUnknown: false };
-  }
-  if (normalized === "application/xml" || normalized.endsWith("+xml")) {
-    return { method: "text", isUnknown: false };
-  }
-  if (normalized === "application/javascript" || normalized === "application/x-javascript" || normalized === "application/ecmascript") {
-    return { method: "text", isUnknown: false };
-  }
-  if (normalized.startsWith("image/")) {
-    return { method: "body", isUnknown: false };
-  }
-  if (normalized.startsWith("audio/")) {
-    return { method: "body", isUnknown: false };
-  }
-  if (normalized.startsWith("video/")) {
-    return { method: "body", isUnknown: false };
-  }
-  if (normalized.startsWith("font/")) {
-    return { method: "body", isUnknown: false };
-  }
-  if (normalized === "application/octet-stream" || normalized === "application/pdf" || normalized === "application/zip" || normalized === "application/gzip" || normalized === "application/x-tar" || normalized === "application/x-7z-compressed" || normalized === "application/x-rar-compressed" || normalized === "application/wasm" || normalized === "application/x-protobuf") {
-    return { method: "body", isUnknown: false };
-  }
-  return { method: fallback, isUnknown: true };
-}
-
-// src/utils/operation-filters.ts
-var import_minimatch2 = require("minimatch");
-function createFilterStatistics() {
-  return {
-    totalOperations: 0,
-    includedOperations: 0,
-    filteredByTags: 0,
-    filteredByPaths: 0,
-    filteredByMethods: 0,
-    filteredByOperationIds: 0,
-    filteredByDeprecated: 0
-  };
-}
-function matchesAnyPattern(value, patterns) {
-  if (!patterns || patterns.length === 0) {
-    return false;
-  }
-  if (!value) {
-    return false;
-  }
-  return patterns.some((pattern) => (0, import_minimatch2.minimatch)(value, pattern));
-}
-function containsAny(arr, values) {
-  if (!values || values.length === 0) {
-    return false;
-  }
-  if (!arr || arr.length === 0) {
-    return false;
-  }
-  return values.some((value) => arr.includes(value));
-}
-function shouldIncludeOperation(operation, path, method, filters, stats) {
-  if (!filters) {
-    return true;
-  }
-  const methodLower = method.toLowerCase();
-  const operationId = operation == null ? void 0 : operation.operationId;
-  const tags = (operation == null ? void 0 : operation.tags) || [];
-  const deprecated = (operation == null ? void 0 : operation.deprecated) === true;
-  if (filters.includeTags && filters.includeTags.length > 0) {
-    if (!containsAny(tags, filters.includeTags)) {
-      if (stats) stats.filteredByTags++;
-      return false;
-    }
-  }
-  if (filters.includePaths && filters.includePaths.length > 0) {
-    if (!matchesAnyPattern(path, filters.includePaths)) {
-      if (stats) stats.filteredByPaths++;
-      return false;
-    }
-  }
-  if (filters.includeMethods && filters.includeMethods.length > 0) {
-    const methodsLower = filters.includeMethods.map((m) => m.toLowerCase());
-    if (!methodsLower.includes(methodLower)) {
-      if (stats) stats.filteredByMethods++;
-      return false;
-    }
-  }
-  if (filters.includeOperationIds && filters.includeOperationIds.length > 0) {
-    if (!matchesAnyPattern(operationId, filters.includeOperationIds)) {
-      if (stats) stats.filteredByOperationIds++;
-      return false;
-    }
-  }
-  if (filters.excludeDeprecated === true && deprecated) {
-    if (stats) stats.filteredByDeprecated++;
-    return false;
-  }
-  if (filters.excludeTags && filters.excludeTags.length > 0) {
-    if (containsAny(tags, filters.excludeTags)) {
-      if (stats) stats.filteredByTags++;
-      return false;
-    }
-  }
-  if (filters.excludePaths && filters.excludePaths.length > 0) {
-    if (matchesAnyPattern(path, filters.excludePaths)) {
-      if (stats) stats.filteredByPaths++;
-      return false;
-    }
-  }
-  if (filters.excludeMethods && filters.excludeMethods.length > 0) {
-    const methodsLower = filters.excludeMethods.map((m) => m.toLowerCase());
-    if (methodsLower.includes(methodLower)) {
-      if (stats) stats.filteredByMethods++;
-      return false;
-    }
-  }
-  if (filters.excludeOperationIds && filters.excludeOperationIds.length > 0) {
-    if (matchesAnyPattern(operationId, filters.excludeOperationIds)) {
-      if (stats) stats.filteredByOperationIds++;
-      return false;
-    }
-  }
-  return true;
-}
-function validateFilters(stats, filters) {
-  if (!filters || stats.totalOperations === 0) {
-    return;
-  }
-  if (stats.includedOperations === 0) {
-    console.warn(
-      `\u26A0\uFE0F  Warning: All ${stats.totalOperations} operations were filtered out. Check your operationFilters configuration.`
-    );
-    const filterBreakdown = [];
-    if (stats.filteredByTags > 0) filterBreakdown.push(`${stats.filteredByTags} by tags`);
-    if (stats.filteredByPaths > 0) filterBreakdown.push(`${stats.filteredByPaths} by paths`);
-    if (stats.filteredByMethods > 0) filterBreakdown.push(`${stats.filteredByMethods} by methods`);
-    if (stats.filteredByOperationIds > 0) filterBreakdown.push(`${stats.filteredByOperationIds} by operationIds`);
-    if (stats.filteredByDeprecated > 0) filterBreakdown.push(`${stats.filteredByDeprecated} by deprecated flag`);
-    if (filterBreakdown.length > 0) {
-      console.warn(`   Filtered: ${filterBreakdown.join(", ")}`);
-    }
-  }
-}
-function formatFilterStatistics(stats) {
-  if (stats.totalOperations === 0) {
-    return "";
-  }
-  const lines = [];
-  lines.push("Operation Filtering:");
-  lines.push(`  Total operations: ${stats.totalOperations}`);
-  lines.push(`  Included operations: ${stats.includedOperations}`);
-  const filteredCount = stats.filteredByTags + stats.filteredByPaths + stats.filteredByMethods + stats.filteredByOperationIds + stats.filteredByDeprecated;
-  if (filteredCount > 0) {
-    lines.push(`  Filtered operations: ${filteredCount}`);
-    if (stats.filteredByTags > 0) lines.push(`    - By tags: ${stats.filteredByTags}`);
-    if (stats.filteredByPaths > 0) lines.push(`    - By paths: ${stats.filteredByPaths}`);
-    if (stats.filteredByMethods > 0) lines.push(`    - By methods: ${stats.filteredByMethods}`);
-    if (stats.filteredByOperationIds > 0) lines.push(`    - By operationIds: ${stats.filteredByOperationIds}`);
-    if (stats.filteredByDeprecated > 0) lines.push(`    - By deprecated: ${stats.filteredByDeprecated}`);
-  }
-  return lines.join("\n");
-}
-
-// src/utils/ref-resolver.ts
-function resolveRef2(obj, spec, maxDepth = 10) {
-  var _a, _b, _c, _d;
-  if (!obj || typeof obj !== "object" || maxDepth <= 0) return obj;
-  if (!obj.$ref) return obj;
-  const ref = obj.$ref;
-  let resolved = null;
-  const paramMatch = ref.match(/^#\/components\/parameters\/(.+)$/);
-  const requestBodyMatch = ref.match(/^#\/components\/requestBodies\/(.+)$/);
-  const responseMatch = ref.match(/^#\/components\/responses\/(.+)$/);
-  const schemaMatch = ref.match(/^#\/components\/schemas\/(.+)$/);
-  if (paramMatch && ((_a = spec.components) == null ? void 0 : _a.parameters)) {
-    const name = paramMatch[1];
-    resolved = spec.components.parameters[name];
-  } else if (requestBodyMatch && ((_b = spec.components) == null ? void 0 : _b.requestBodies)) {
-    const name = requestBodyMatch[1];
-    resolved = spec.components.requestBodies[name];
-  } else if (responseMatch && ((_c = spec.components) == null ? void 0 : _c.responses)) {
-    const name = responseMatch[1];
-    resolved = spec.components.responses[name];
-  } else if (schemaMatch && ((_d = spec.components) == null ? void 0 : _d.schemas)) {
-    const name = schemaMatch[1];
-    resolved = spec.components.schemas[name];
-  }
-  if (resolved) {
-    if (resolved.$ref) {
-      return resolveRef2(resolved, spec, maxDepth - 1);
-    }
-    return resolved;
-  }
-  return obj;
-}
-function resolveParameterRef(param, spec) {
-  return resolveRef2(param, spec);
-}
-function resolveRequestBodyRef(requestBody, spec) {
-  return resolveRef2(requestBody, spec);
-}
-function resolveResponseRef(response, spec) {
-  return resolveRef2(response, spec);
-}
-function mergeParameters(pathParams, operationParams, spec) {
-  const resolvedPathParams = (pathParams || []).map((p) => resolveParameterRef(p, spec));
-  const resolvedOperationParams = (operationParams || []).map((p) => resolveParameterRef(p, spec));
-  const merged = [...resolvedPathParams];
-  for (const opParam of resolvedOperationParams) {
-    if (!opParam || typeof opParam !== "object") continue;
-    const existingIndex = merged.findIndex(
-      (p) => p && typeof p === "object" && p.name === opParam.name && p.in === opParam.in
-    );
-    if (existingIndex >= 0) {
-      merged[existingIndex] = opParam;
-    } else {
-      merged.push(opParam);
-    }
-  }
-  return merged;
-}
-
-// src/utils/typescript-loader.ts
-function createTypeScriptLoader() {
-  return async (filepath) => {
-    try {
-      const esbuild = await import("esbuild");
-      const fs = await import("fs");
-      const path = await import("path");
-      const tsCode = fs.readFileSync(filepath, "utf-8");
-      const result = await esbuild.build({
-        stdin: {
-          contents: tsCode,
-          loader: "ts",
-          resolveDir: path.dirname(filepath),
-          sourcefile: filepath
-        },
-        format: "cjs",
-        platform: "node",
-        target: "node18",
-        bundle: false,
-        write: false
-      });
-      const jsCode = result.outputFiles[0].text;
-      const module2 = { exports: {} };
-      const func = new Function("exports", "module", "require", "__filename", "__dirname", jsCode);
-      func(module2.exports, module2, require, filepath, path.dirname(filepath));
-      return module2.exports.default || module2.exports;
-    } catch (error) {
-      throw new Error(
-        `Failed to load TypeScript config from ${filepath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LRUCache,
-  OperationFiltersSchema,
-  PropertyGenerator,
-  RequestResponseOptionsSchema,
-  buildDateTimeValidation,
-  createFilterStatistics,
-  createTypeScriptLoader,
-  escapeJSDoc,
-  executeBatch,
-  formatConfigValidationError,
-  formatFilterStatistics,
-  getBatchExitCode,
-  getResponseParseMethod,
-  mergeParameters,
-  resolveParameterRef,
-  resolveRef,
-  resolveRequestBodyRef,
-  resolveResponseRef,
-  shouldIncludeOperation,
-  stripPathPrefix,
-  stripPrefix,
-  toCamelCase,
-  toPascalCase,
-  validateFilters
-});
-//# sourceMappingURL=internal.js.map