@cerios/openapi-to-zod 1.3.2 → 1.5.0

package/dist/internal.mjs

@@ -1,706 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// 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/config-schemas.ts
-import { z } from "zod";
-var RequestResponseOptionsSchema = z.strictObject({
-  mode: z.enum(["strict", "normal", "loose"]).optional(),
-  useDescribe: z.boolean().optional(),
-  includeDescriptions: z.boolean().optional(),
-  defaultNullable: z.boolean().optional(),
-  emptyObjectBehavior: z.enum(["strict", "loose", "record"]).optional()
-});
-var OperationFiltersSchema = z.strictObject({
-  includeTags: z.array(z.string()).optional(),
-  excludeTags: z.array(z.string()).optional(),
-  includePaths: z.array(z.string()).optional(),
-  excludePaths: z.array(z.string()).optional(),
-  includeMethods: z.array(z.string()).optional(),
-  excludeMethods: z.array(z.string()).optional(),
-  includeOperationIds: z.array(z.string()).optional(),
-  excludeOperationIds: z.array(z.string()).optional(),
-  excludeDeprecated: 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/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;
-}
-
-// src/utils/operation-filters.ts
-import { minimatch } from "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) => 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/pattern-utils.ts
-import { minimatch as minimatch2 } from "minimatch";
-function isValidGlobPattern(pattern) {
-  try {
-    new minimatch2.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 (minimatch2(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/ref-resolver.ts
-function resolveRef(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 resolveRef(resolved, spec, maxDepth - 1);
-    }
-    return resolved;
-  }
-  return obj;
-}
-function resolveParameterRef(param, spec) {
-  return resolveRef(param, spec);
-}
-function resolveRequestBodyRef(requestBody, spec) {
-  return resolveRef(requestBody, spec);
-}
-function resolveResponseRef(response, spec) {
-  return resolveRef(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/string-utils.ts
-function escapePattern(str) {
-  return str.replace(/\//g, "\\/");
-}
-function escapeJSDoc(str) {
-  return str.replace(/\*\//g, "*\\/");
-}
-
-// 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 module = { exports: {} };
-      const func = new Function("exports", "module", "require", "__filename", "__dirname", jsCode);
-      func(module.exports, module, __require, filepath, path.dirname(filepath));
-      return module.exports.default || module.exports;
-    } catch (error) {
-      throw new Error(
-        `Failed to load TypeScript config from ${filepath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  };
-}
-
-// src/validators/string-validator.ts
-var PATTERN_CACHE = new LRUCache(1e3);
-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" })'
-};
-var FORMAT_MAP = {
-  ...DEFAULT_FORMAT_MAP,
-  "date-time": "z.iso.datetime()"
-};
-function configureDateTimeFormat(pattern) {
-  if (!pattern) {
-    FORMAT_MAP["date-time"] = "z.iso.datetime()";
-    return;
-  }
-  const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
-  if (patternStr === "") {
-    FORMAT_MAP["date-time"] = "z.iso.datetime()";
-    return;
-  }
-  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);
-  FORMAT_MAP["date-time"] = `z.string().regex(/${escapedPattern}/)`;
-}
-function resetFormatMap() {
-  FORMAT_MAP = {
-    ...DEFAULT_FORMAT_MAP,
-    "date-time": "z.iso.datetime()"
-  };
-}
-export {
-  LRUCache,
-  OperationFiltersSchema,
-  RequestResponseOptionsSchema,
-  configureDateTimeFormat,
-  createFilterStatistics,
-  createTypeScriptLoader,
-  escapeJSDoc,
-  executeBatch,
-  formatConfigValidationError,
-  formatFilterStatistics,
-  getBatchExitCode,
-  getResponseParseMethod,
-  mergeParameters,
-  resetFormatMap,
-  resolveParameterRef,
-  resolveRef,
-  resolveRequestBodyRef,
-  resolveResponseRef,
-  shouldIncludeOperation,
-  stripPathPrefix,
-  stripPrefix,
-  toCamelCase,
-  toPascalCase,
-  validateFilters
-};
-//# sourceMappingURL=internal.mjs.map