@cerios/openapi-to-zod 1.4.0 → 1.5.0

package/dist/index.mjs

@@ -1,193 +1,30 @@
-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 SpecValidationError = class extends GeneratorError {
-  constructor(message, context) {
-    super(message, "SPEC_VALIDATION_ERROR", context);
-    this.name = "SpecValidationError";
-  }
-};
-var FileOperationError = class extends GeneratorError {
-  constructor(message, filePath, context) {
-    super(message, "FILE_OPERATION_ERROR", { ...context, filePath });
-    this.filePath = filePath;
-    this.name = "FileOperationError";
-  }
-};
-var ConfigValidationError = class extends GeneratorError {
-  constructor(message, configPath, context) {
-    super(message, "CONFIG_VALIDATION_ERROR", { ...context, configPath });
-    this.configPath = configPath;
-    this.name = "ConfigValidationError";
-  }
-};
-var SchemaGenerationError = class extends GeneratorError {
-  constructor(message, schemaName, context) {
-    super(message, "SCHEMA_GENERATION_ERROR", { ...context, schemaName });
-    this.schemaName = schemaName;
-    this.name = "SchemaGenerationError";
-  }
-};
-var CircularReferenceError = class extends SchemaGenerationError {
-  constructor(schemaName, referencePath) {
-    const pathStr = referencePath.join(" -> ");
-    super(`Circular reference detected in schema: ${pathStr}`, schemaName, { referencePath, circularPath: pathStr });
-    this.referencePath = referencePath;
-    this.name = "CircularReferenceError";
-  }
-};
-var CliOptionsError = class extends GeneratorError {
-  constructor(message, context) {
-    super(message, "CLI_OPTIONS_ERROR", context);
-    this.name = "CliOptionsError";
-  }
-};
-var ConfigurationError = class extends GeneratorError {
-  constructor(message, context) {
-    super(message, "CONFIGURATION_ERROR", context);
-    this.name = "ConfigurationError";
-  }
-};
-
-// src/openapi-generator.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, normalize } from "path";
-import { minimatch as minimatch3 } from "minimatch";
-import { parse } from "yaml";
-
-// 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/index.ts
+import {
+  CircularReferenceError,
+  CliOptionsError,
+  ConfigValidationError,
+  FileOperationError,
+  GeneratorError,
+  SchemaGenerationError as SchemaGenerationError2,
+  SpecValidationError as SpecValidationError2
+} from "@cerios/openapi-core";
 
-// src/generators/enum-generator.ts
-function generateEnum(name, values, options) {
-  const schemaName = `${toCamelCase(name, options)}Schema`;
-  const typeName = toPascalCase(name);
-  const allBooleans = values.every((v) => typeof v === "boolean");
-  if (allBooleans) {
-    const schemaCode2 = `export const ${schemaName} = z.boolean();`;
-    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
-    return { schemaCode: schemaCode2, typeCode: typeCode2 };
-  }
-  const allStrings = values.every((v) => typeof v === "string");
-  if (allStrings) {
-    const enumValues = values.map((v) => `"${v}"`).join(", ");
-    const schemaCode2 = `export const ${schemaName} = z.enum([${enumValues}]);`;
-    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
-    return { schemaCode: schemaCode2, typeCode: typeCode2 };
-  }
-  const literalValues = values.map((v) => {
-    if (typeof v === "string") {
-      return `z.literal("${v}")`;
-    }
-    return `z.literal(${v})`;
-  }).join(", ");
-  const schemaCode = `export const ${schemaName} = z.union([${literalValues}]);`;
-  const typeCode = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
-  return { schemaCode, typeCode };
-}
+// src/generators/property-generator.ts
+import {
+  getPrimaryType,
+  hasMultipleTypes,
+  isNullable,
+  LRUCache,
+  resolveRefName,
+  stripPrefix,
+  toCamelCase,
+  toPascalCase
+} from "@cerios/openapi-core";
 
 // 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;
+import { escapeDescription } from "@cerios/openapi-core";
+function wrapNullable(validation, nullable) {
+  return nullable ? `${validation}.nullable()` : validation;
 }
 function addDescription(validation, description, useDescribe) {
   if (!description || !useDescribe) return validation;
@@ -195,167 +32,6 @@ function addDescription(validation, description, useDescribe) {
   return `${validation}.describe("${escapedDesc}")`;
 }
 
-// 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/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/pattern-utils.ts
-import { minimatch } from "minimatch";
-function isValidGlobPattern(pattern) {
-  try {
-    new 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 (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/validators/array-validator.ts
 function generateArrayValidation(schema, context) {
   var _a;
@@ -523,15 +199,14 @@ function detectConflictingProperties(schemas, context) {
 function generateAllOf(schemas, isNullable2, context, currentSchema) {
   if (schemas.length === 1) {
     const singleSchema = context.generatePropertySchema(schemas[0], currentSchema, false, true);
-    return wrapNullable(singleSchema, isNullable2);
+    return { schema: wrapNullable(singleSchema, isNullable2), conflicts: [] };
   }
   const conflicts = detectConflictingProperties(schemas, context);
-  let conflictDescription = "";
-  if (conflicts.length > 0) {
-    for (const conflict of conflicts) {
+  const uniqueConflicts = [...new Set(conflicts)];
+  if (uniqueConflicts.length > 0) {
+    for (const conflict of uniqueConflicts) {
       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;
@@ -559,10 +234,7 @@ function generateAllOf(schemas, isNullable2, context, currentSchema) {
     }
     result = merged;
   }
-  if (conflictDescription) {
-    result = `${result}.describe("${conflictDescription}")`;
-  }
-  return wrapNullable(result, isNullable2);
+  return { schema: wrapNullable(result, isNullable2), conflicts: uniqueConflicts };
 }
 
 // src/validators/number-validator.ts
@@ -586,6 +258,53 @@ function generateNumberValidation(schema, isInt, useDescribe) {
   return addDescription(validation, schema.description, useDescribe);
 }
 
+// src/generators/jsdoc-generator.ts
+import { escapeJSDoc } from "@cerios/openapi-core";
+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)) {
+    parts.push(escapeJSDoc(schema.title));
+  }
+  if (schema.description && typeof schema.description === "string") {
+    parts.push(escapeJSDoc(schema.description));
+  }
+  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_$]*$/;
@@ -644,7 +363,8 @@ function generateConditionalCheck(schema) {
     for (const [prop, propSchema] of Object.entries(schema.properties)) {
       const propAccess = generatePropertyAccess(prop);
       if (propSchema.type) {
-        conditions.push(`typeof ${propAccess} === "${propSchema.type}"`);
+        const schemaType = Array.isArray(propSchema.type) ? propSchema.type[0] : propSchema.type;
+        conditions.push(`typeof ${propAccess} === "${schemaType}"`);
       }
       if (propSchema.const !== void 0) {
         const value = typeof propSchema.const === "string" ? `"${propSchema.const}"` : propSchema.const;
@@ -703,7 +423,7 @@ function generateIfThenElse(schema) {
 				if (!thenValid) {
 					${thenRequiredProps.length > 0 ? `
 					const missingThenProps = ${JSON.stringify(thenRequiredProps)}.filter(p => obj[p] === undefined);
-					const message = missingThenProps.length > 0 
+					const message = missingThenProps.length > 0
 						? \`When condition is met, required properties are missing: \${missingThenProps.join(', ')}\`
 						: "When condition is met, validation constraints failed";
 					` : `
@@ -721,7 +441,7 @@ function generateIfThenElse(schema) {
 				if (!elseValid) {
 					${elseRequiredProps2.length > 0 ? `
 					const missingElseProps = ${JSON.stringify(elseRequiredProps2)}.filter(p => obj[p] === undefined);
-					const message = missingElseProps.length > 0 
+					const message = missingElseProps.length > 0
 						? \`When condition is not met, required properties are missing: \${missingElseProps.join(', ')}\`
 						: "When condition is not met, validation constraints failed";
 					` : `
@@ -746,7 +466,7 @@ function generateIfThenElse(schema) {
 				if (!thenValid) {
 					${thenRequiredProps.length > 0 ? `
 					const missingProps = ${JSON.stringify(thenRequiredProps)}.filter(p => obj[p] === undefined);
-					const message = missingProps.length > 0 
+					const message = missingProps.length > 0
 						? \`When condition is met, required properties are missing: \${missingProps.join(', ')}\`
 						: "When condition is met, validation constraints failed";
 					` : `
@@ -771,7 +491,7 @@ function generateIfThenElse(schema) {
 			if (!elseValid) {
 				${elseRequiredProps.length > 0 ? `
 				const missingProps = ${JSON.stringify(elseRequiredProps)}.filter(p => obj[p] === undefined);
-				const message = missingProps.length > 0 
+				const message = missingProps.length > 0
 					? \`When condition is not met, required properties are missing: \${missingProps.join(', ')}\`
 					: "When condition is not met, validation constraints failed";
 				` : `
@@ -859,8 +579,9 @@ ${propertyDef}`);
       case "loose":
         objectMethod = "z.looseObject";
         break;
-      default:
+      case "normal":
         objectMethod = "z.object";
+        break;
     }
   }
   let objectDef = `${objectMethod}({
@@ -870,7 +591,7 @@ ${properties.join(",\n")}
     if (typeof schema.additionalProperties === "object") {
       const additionalSchema = context.generatePropertySchema(schema.additionalProperties, currentSchema);
       objectDef += `.catchall(${additionalSchema})`;
-    } else if (schema.additionalProperties === true) {
+    } else if (schema.additionalProperties) {
       objectDef += ".catchall(z.unknown())";
     }
   } else if (schema.patternProperties) {
@@ -995,6 +716,7 @@ ${properties.join(",\n")}
 }
 
 // src/validators/string-validator.ts
+import { escapePattern } from "@cerios/openapi-core";
 var DEFAULT_FORMAT_MAP = {
   uuid: "z.uuid()",
   email: "z.email()",
@@ -1120,8 +842,32 @@ var _PropertyGenerator = class _PropertyGenerator {
     this.filteredPropsCache = /* @__PURE__ */ new Map();
     // Performance optimization: LRU cache for generated schemas
     this.schemaCache = new LRUCache(500);
+    // Track allOf conflicts detected during schema generation
+    this.allOfConflicts = [];
+    // Schemas that are part of circular dependency chains (need z.lazy for forward refs)
+    this.circularDependencies = /* @__PURE__ */ new Set();
     this.context = context;
   }
+  /**
+   * Set the schemas that are involved in circular dependency chains.
+   * These schemas will use z.lazy() for forward references.
+   */
+  setCircularDependencies(deps) {
+    this.circularDependencies = deps;
+  }
+  /**
+   * Get allOf conflicts detected during the last schema generation
+   * @returns Array of conflict description strings
+   */
+  getAllOfConflicts() {
+    return [...this.allOfConflicts];
+  }
+  /**
+   * Clear tracked allOf conflicts (call before generating a new schema)
+   */
+  clearAllOfConflicts() {
+    this.allOfConflicts = [];
+  }
   /**
    * Check if a property should be included based on schemaType and readOnly/writeOnly flags
    */
@@ -1154,7 +900,9 @@ var _PropertyGenerator = class _PropertyGenerator {
   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 requiredKeys = Array.isArray(schema.required) ? schema.required.join(",") : String((_a = schema.required) != null ? _a : "");
+    const schemaType = Array.isArray(schema.type) ? schema.type.join("|") : schema.type || "unknown";
+    const cacheKey = `${this.context.schemaType}:${schemaType}:${propKeys}:${requiredKeys}`;
     const cached = this.filteredPropsCache.get(cacheKey);
     if (cached) {
       return cached;
@@ -1250,7 +998,7 @@ var _PropertyGenerator = class _PropertyGenerator {
     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);
+      const targetName = resolveRefName(schema.allOf[0].$ref);
       return this.resolveSchemaAlias(targetName);
     }
     return schemaName;
@@ -1263,7 +1011,7 @@ var _PropertyGenerator = class _PropertyGenerator {
     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);
+      const aliasTarget = resolveRefName(toSchemaSpec.allOf[0].$ref);
       return aliasTarget === fromSchema;
     }
     return false;
@@ -1364,7 +1112,7 @@ var _PropertyGenerator = class _PropertyGenerator {
       return wrapNullable(union, nullable);
     }
     if (schema.$ref) {
-      const refName = resolveRef(schema.$ref);
+      const refName = resolveRefName(schema.$ref);
       const resolvedRefName = this.resolveSchemaAlias(refName);
       if (currentSchema && refName !== currentSchema && !isTopLevel) {
         if (!this.context.schemaDependencies.has(currentSchema)) {
@@ -1374,8 +1122,13 @@ var _PropertyGenerator = class _PropertyGenerator {
       }
       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})`;
+      const typeName = toPascalCase(strippedRefName);
+      const isDirectSelfRef = currentSchema && refName === currentSchema;
+      const isCircularAlias = currentSchema && this.isCircularThroughAlias(currentSchema, refName);
+      const isMutuallyCircular = currentSchema && this.circularDependencies.has(currentSchema) && this.circularDependencies.has(refName);
+      if (isDirectSelfRef || isCircularAlias || isMutuallyCircular) {
+        const lazyTypeAnnotation = this.context.separateTypesFile ? `z.ZodType<${typeName}>` : "z.ZodTypeAny";
+        const lazySchema = `z.lazy((): ${lazyTypeAnnotation} => ${schemaName})`;
         return wrapNullable(lazySchema, nullable);
       }
       return wrapNullable(schemaName, nullable);
@@ -1408,7 +1161,7 @@ var _PropertyGenerator = class _PropertyGenerator {
     }
     if (schema.allOf) {
       const compositionNullable = isNullable(schema, false);
-      let composition = generateAllOf(
+      const allOfResult = generateAllOf(
         schema.allOf,
         compositionNullable,
         {
@@ -1418,6 +1171,10 @@ var _PropertyGenerator = class _PropertyGenerator {
         },
         currentSchema
       );
+      if (allOfResult.conflicts.length > 0) {
+        this.allOfConflicts.push(...allOfResult.conflicts);
+      }
+      let composition = allOfResult.schema;
       if (schema.unevaluatedProperties !== void 0) {
         composition = this.applyUnevaluatedProperties(composition, schema);
       }
@@ -1529,13 +1286,14 @@ var _PropertyGenerator = class _PropertyGenerator {
             case "loose":
               validation = "z.looseObject({})";
               break;
-            default:
+            case "record":
               validation = "z.record(z.string(), z.unknown())";
               break;
           }
           validation = addDescription(validation, schema.description, this.context.useDescribe);
         }
         break;
+      case void 0:
       default:
         validation = "z.unknown()";
         validation = addDescription(validation, schema.description, this.context.useDescribe);
@@ -1594,194 +1352,71 @@ _PropertyGenerator.INCLUSION_RULES = {
 };
 var PropertyGenerator = _PropertyGenerator;
 
-// src/utils/operation-filters.ts
-import { minimatch as minimatch2 } 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) => minimatch2(value, pattern));
-}
-function containsAny(arr, values) {
-  if (!values || values.length === 0) {
-    return false;
+// src/openapi-generator.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, normalize, relative } from "path";
+import {
+  analyzeSchemaUsage,
+  ConfigurationError,
+  createFilterStatistics,
+  detectCircularReferences,
+  expandTransitiveReferences,
+  extractSchemaRefs,
+  formatFilterStatistics,
+  getOperationName,
+  LRUCache as LRUCache2,
+  loadOpenAPISpec,
+  mergeParameters,
+  resolveRefName as resolveRefName2,
+  SchemaGenerationError,
+  SpecValidationError,
+  shouldIncludeOperation,
+  stripPathPrefix,
+  stripPrefix as stripPrefix2,
+  toCamelCase as toCamelCase3,
+  toPascalCase as toPascalCase3,
+  validateFilters
+} from "@cerios/openapi-core";
+import { TypeScriptGenerator } from "@cerios/openapi-to-typescript";
+import { minimatch } from "minimatch";
+
+// src/generators/enum-generator.ts
+import { toCamelCase as toCamelCase2, toPascalCase as toPascalCase2 } from "@cerios/openapi-core";
+function generateEnum(name, values, options) {
+  const schemaName = `${toCamelCase2(name, options)}Schema`;
+  const typeName = toPascalCase2(name);
+  const allBooleans = values.every((v) => typeof v === "boolean");
+  if (allBooleans) {
+    const schemaCode2 = `export const ${schemaName} = z.boolean();`;
+    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+    return { schemaCode: schemaCode2, typeCode: typeCode2 };
   }
-  if (!arr || arr.length === 0) {
-    return false;
+  const allStrings = values.every((v) => typeof v === "string");
+  if (allStrings) {
+    const enumValues = values.map((v) => `"${v}"`).join(", ");
+    const schemaCode2 = `export const ${schemaName} = z.enum([${enumValues}]);`;
+    const typeCode2 = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+    return { schemaCode: schemaCode2, typeCode: typeCode2 };
   }
-  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;
+  const literalValues = values.map((v) => {
+    if (typeof v === "string") {
+      return `z.literal("${v}")`;
     }
-  }
-  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");
+    return `z.literal(${v})`;
+  }).join(", ");
+  const schemaCode = `export const ${schemaName} = z.union([${literalValues}]);`;
+  const typeCode = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
+  return { schemaCode, typeCode };
 }
 
-// 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);
+// src/openapi-generator.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options"];
+function isResolvedParameter(param) {
+  return typeof param === "object" && param !== null && "name" in param && typeof param.name === "string" && "in" in param;
 }
-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;
+function isOpenAPIPathItem(value) {
+  return typeof value === "object" && value !== null;
 }
-
-// src/openapi-generator.ts
 var OpenApiGenerator = class {
   constructor(options) {
     this.schemas = /* @__PURE__ */ new Map();
@@ -1790,89 +1425,48 @@ var OpenApiGenerator = class {
     this.schemaUsageMap = /* @__PURE__ */ new Map();
     this.needsZodImport = true;
     this.filterStats = createFilterStatistics();
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    /** Track total allOf conflicts detected across all schemas */
+    this.allOfConflictCount = 0;
+    /** Track schemas involved in circular dependency chains */
+    this.circularDependencies = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     if (!options.input) {
       throw new ConfigurationError("Input path is required", { providedOptions: options });
     }
+    this.separateSchemasMode = Boolean(options.outputZodSchemas);
     this.options = {
       mode: options.mode || "normal",
       input: options.input,
-      output: options.output,
-      includeDescriptions: (_a = options.includeDescriptions) != null ? _a : true,
-      useDescribe: (_b = options.useDescribe) != null ? _b : false,
-      defaultNullable: (_c = options.defaultNullable) != null ? _c : false,
-      emptyObjectBehavior: (_d = options.emptyObjectBehavior) != null ? _d : "loose",
+      outputTypes: options.outputTypes,
+      outputZodSchemas: options.outputZodSchemas,
+      enumFormat: options.enumFormat,
+      typeAssertionThreshold: (_a = options.typeAssertionThreshold) != null ? _a : 0,
+      includeDescriptions: (_b = options.includeDescriptions) != null ? _b : true,
+      useDescribe: (_c = options.useDescribe) != null ? _c : false,
+      defaultNullable: (_d = options.defaultNullable) != null ? _d : false,
+      emptyObjectBehavior: (_e = options.emptyObjectBehavior) != null ? _e : "loose",
       schemaType: options.schemaType || "all",
       prefix: options.prefix,
       suffix: options.suffix,
       stripSchemaPrefix: options.stripSchemaPrefix,
       stripPathPrefix: options.stripPathPrefix,
-      showStats: (_e = options.showStats) != null ? _e : true,
+      useOperationId: (_f = options.useOperationId) != null ? _f : true,
+      showStats: (_g = options.showStats) != null ? _g : true,
       request: options.request,
       response: options.response,
       operationFilters: options.operationFilters,
       ignoreHeaders: options.ignoreHeaders,
-      cacheSize: (_f = options.cacheSize) != null ? _f : 1e3,
-      batchSize: (_g = options.batchSize) != null ? _g : 10,
+      cacheSize: (_h = options.cacheSize) != null ? _h : 1e3,
+      batchSize: (_i = options.batchSize) != null ? _i : 10,
       customDateTimeFormatRegex: options.customDateTimeFormatRegex
     };
-    this.patternCache = new LRUCache((_h = this.options.cacheSize) != null ? _h : 1e3);
+    this.patternCache = new LRUCache2((_j = this.options.cacheSize) != null ? _j : 1e3);
     this.dateTimeValidation = buildDateTimeValidation(this.options.customDateTimeFormatRegex);
-    try {
-      const fs = __require("fs");
-      if (!fs.existsSync(this.options.input)) {
-        throw new FileOperationError(`Input file not found: ${this.options.input}`, this.options.input);
-      }
-    } catch (error) {
-      if (error instanceof FileOperationError) {
-        throw error;
-      }
-    }
-    try {
-      const content = readFileSync(this.options.input, "utf-8");
-      try {
-        this.spec = parse(content);
-      } catch (yamlError) {
-        try {
-          this.spec = JSON.parse(content);
-        } catch {
-          if (yamlError instanceof Error) {
-            const errorMessage = [
-              `Failed to parse OpenAPI specification from: ${this.options.input}`,
-              "",
-              `Error: ${yamlError.message}`,
-              "",
-              "Please ensure:",
-              "  - The file exists and is readable",
-              "  - The file contains valid YAML or JSON syntax",
-              "  - The file is a valid OpenAPI 3.x specification"
-            ].join("\n");
-            throw new SpecValidationError(errorMessage, {
-              filePath: this.options.input,
-              originalError: yamlError.message
-            });
-          }
-          throw yamlError;
-        }
-      }
-    } catch (error) {
-      if (error instanceof SpecValidationError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        const errorMessage = [
-          `Failed to read OpenAPI specification from: ${this.options.input}`,
-          "",
-          `Error: ${error.message}`
-        ].join("\n");
-        throw new SpecValidationError(errorMessage, { filePath: this.options.input, originalError: error.message });
-      }
-      throw error;
-    }
+    this.spec = loadOpenAPISpec(this.options.input);
     this.validateSpec();
     this.requestOptions = this.resolveOptionsForContext("request");
     this.responseOptions = this.resolveOptionsForContext("response");
-    this.analyzeSchemaUsage();
+    this.initializeSchemaUsage();
     this.propertyGenerator = new PropertyGenerator({
       spec: this.spec,
       schemaDependencies: this.schemaDependencies,
@@ -1880,19 +1474,21 @@ var OpenApiGenerator = class {
       mode: this.requestOptions.mode,
       includeDescriptions: this.requestOptions.includeDescriptions,
       useDescribe: this.requestOptions.useDescribe,
-      defaultNullable: (_i = this.options.defaultNullable) != null ? _i : false,
-      emptyObjectBehavior: (_j = this.options.emptyObjectBehavior) != null ? _j : "loose",
+      defaultNullable: (_k = this.options.defaultNullable) != null ? _k : false,
+      emptyObjectBehavior: (_l = this.options.emptyObjectBehavior) != null ? _l : "loose",
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
       },
       stripSchemaPrefix: this.options.stripSchemaPrefix,
       dateTimeValidation: this.dateTimeValidation,
-      patternCache: this.patternCache
+      patternCache: this.patternCache,
+      separateTypesFile: this.separateSchemasMode
     });
   }
   /**
    * Generate schemas as a string (without writing to file)
+   * When separateSchemasMode is active, generates Zod schemas with explicit type annotations
    * @returns The generated TypeScript code as a string
    */
   generateString() {
@@ -1900,6 +1496,11 @@ var OpenApiGenerator = class {
     if (!((_a = this.spec.components) == null ? void 0 : _a.schemas)) {
       throw new SpecValidationError("No schemas found in OpenAPI spec", { filePath: this.options.input });
     }
+    if (this.separateSchemasMode) {
+      return this.generateSeparateSchemasString();
+    }
+    this.analyzeCircularDependencies();
+    this.propertyGenerator.setCircularDependencies(this.circularDependencies);
     for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
       if (this.options.operationFilters && this.schemaUsageMap.size > 0 && !this.schemaUsageMap.has(name)) {
         continue;
@@ -1925,10 +1526,10 @@ var OpenApiGenerator = class {
       const typeCode = this.types.get(name);
       if (schemaCode) {
         output.push(schemaCode);
-        const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
-        const typeName = toPascalCase(strippedName);
+        const strippedName = stripPrefix2(name, this.options.stripSchemaPrefix);
+        const typeName = toPascalCase3(strippedName);
         if (!schemaCode.includes(`export type ${typeName}`)) {
-          const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+          const schemaName = `${toCamelCase3(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
           output.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
         }
         output.push("");
@@ -1950,14 +1551,224 @@ var OpenApiGenerator = class {
     }
   }
   /**
-   * Generate the complete output file
+   * Generate the complete output file(s)
+   * When separateSchemasMode is active, generates both types and schemas files
    */
   generate() {
-    const output = this.generateString();
-    const normalizedOutput = normalize(this.options.output);
-    this.ensureDirectoryExists(normalizedOutput);
-    writeFileSync(normalizedOutput, output);
-    console.log(`  \u2713 Generated ${normalizedOutput}`);
+    if (this.separateSchemasMode) {
+      const typesContent = this.generateTypesString();
+      const schemasContent = this.generateString();
+      const normalizedTypes = normalize(this.options.outputTypes);
+      this.ensureDirectoryExists(normalizedTypes);
+      writeFileSync(normalizedTypes, typesContent, "utf-8");
+      console.log(`  \u2713 Generated ${normalizedTypes}`);
+      if (!this.options.outputZodSchemas) {
+        throw new Error("Internal error: outputZodSchemas should be defined in separateSchemasMode");
+      }
+      const outputZodSchemas = this.options.outputZodSchemas;
+      const normalizedSchemas = normalize(outputZodSchemas);
+      this.ensureDirectoryExists(normalizedSchemas);
+      writeFileSync(normalizedSchemas, schemasContent, "utf-8");
+      console.log(`  \u2713 Generated ${normalizedSchemas}`);
+    } else {
+      const output = this.generateString();
+      const normalizedOutput = normalize(this.options.outputTypes);
+      this.ensureDirectoryExists(normalizedOutput);
+      writeFileSync(normalizedOutput, output);
+      console.log(`  \u2713 Generated ${normalizedOutput}`);
+    }
+  }
+  /**
+   * Generate Zod schemas with explicit type annotations (for outputZodSchemas mode)
+   * Generates schemas like: `export const userSchema: z.ZodType<User> = z.object({...})`
+   * @returns The generated Zod schemas TypeScript code
+   */
+  generateSeparateSchemasString() {
+    var _a;
+    const schemas = (_a = this.spec.components) == null ? void 0 : _a.schemas;
+    if (!schemas) {
+      return "";
+    }
+    if (!this.options.outputZodSchemas) {
+      throw new Error("Internal error: outputZodSchemas should be defined in separateSchemasMode");
+    }
+    const outputZodSchemas = this.options.outputZodSchemas;
+    this.analyzeCircularDependencies();
+    this.propertyGenerator.setCircularDependencies(this.circularDependencies);
+    for (const [name, schema] of Object.entries(schemas)) {
+      if (this.options.operationFilters && this.schemaUsageMap.size > 0 && !this.schemaUsageMap.has(name)) {
+        continue;
+      }
+      this.generateComponentSchema(name, schema);
+    }
+    this.generateQueryParameterSchemas();
+    this.generateHeaderParameterSchemas();
+    validateFilters(this.filterStats, this.options.operationFilters);
+    const orderedSchemaNames = this.topologicalSort();
+    const output = ["// Auto-generated by @cerios/openapi-to-zod", "// Do not edit this file manually", ""];
+    if (this.options.showStats === true) {
+      output.push(...this.generateStats());
+      output.push("");
+    }
+    output.push('import { z } from "zod";');
+    const typesImportPath = this.calculateRelativeImportPath(outputZodSchemas, this.options.outputTypes);
+    const typeNames = [];
+    for (const name of orderedSchemaNames) {
+      const strippedName = stripPrefix2(name, this.options.stripSchemaPrefix);
+      const typeName = toPascalCase3(strippedName);
+      typeNames.push(typeName);
+    }
+    if (typeNames.length > 0) {
+      output.push(`import type { ${typeNames.join(", ")} } from "${typesImportPath}";`);
+    }
+    output.push("");
+    output.push("// Schemas");
+    for (const name of orderedSchemaNames) {
+      const schemaCode = this.schemas.get(name);
+      if (schemaCode) {
+        const strippedName = stripPrefix2(name, this.options.stripSchemaPrefix);
+        const typeName = toPascalCase3(strippedName);
+        const schemaName = `${toCamelCase3(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+        const schemaDefinition = this.isRecordObject(schemas[name]) ? schemas[name] : void 0;
+        const transformedCode = this.addExplicitTypeAnnotation(schemaCode, schemaName, typeName, schemaDefinition);
+        output.push(transformedCode);
+        output.push("");
+      }
+    }
+    return output.join("\n");
+  }
+  /**
+   * Generate TypeScript types as a string (for outputZodSchemas mode)
+   * Uses @cerios/openapi-to-typescript internally
+   * @returns The generated TypeScript types code
+   */
+  generateTypesString() {
+    var _a;
+    const tsGenerator = new TypeScriptGenerator({
+      input: this.options.input,
+      outputTypes: this.options.outputTypes,
+      includeDescriptions: this.options.includeDescriptions,
+      defaultNullable: this.options.defaultNullable,
+      prefix: this.options.prefix,
+      suffix: this.options.suffix,
+      stripSchemaPrefix: this.options.stripSchemaPrefix,
+      stripPathPrefix: this.options.stripPathPrefix,
+      operationFilters: this.options.operationFilters,
+      showStats: this.options.showStats,
+      enumFormat: (_a = this.options.enumFormat) != null ? _a : "const-object"
+    });
+    return tsGenerator.generateString();
+  }
+  /**
+   * Add explicit type annotation to a schema declaration
+   * Transforms: `export const userSchema = z.object({...})`
+   * To: `export const userSchema: z.ZodType<User> = z.object({...})` (annotation)
+   * Or: `export const userSchema = z.object({...}) as unknown as z.ZodType<User>` (double assertion)
+   *
+   * Uses double assertion via `unknown` when typeAssertionThreshold is set and schema complexity
+   * meets or exceeds the threshold. This completely bypasses TypeScript's structural checking
+   * to avoid "Type instantiation is excessively deep" errors on very large schemas.
+   *
+   * Also removes any `export type X = z.infer<...>` lines since types
+   * are imported from the separate types file.
+   */
+  addExplicitTypeAnnotation(schemaCode, schemaName, typeName, schemaDefinition) {
+    var _a;
+    const code = schemaCode.replace(/\nexport type \w+ = z\.infer<typeof \w+>;/g, "");
+    const jsdocMatch = code.match(/^(\/\*\*[\s\S]*?\*\/\n)?/);
+    const jsdoc = (jsdocMatch == null ? void 0 : jsdocMatch[1]) || "";
+    const codeWithoutJsdoc = code.slice(jsdoc.length);
+    const threshold = (_a = this.options.typeAssertionThreshold) != null ? _a : 0;
+    const useAssertion = threshold > 0 && schemaDefinition && this.calculateSchemaComplexity(schemaDefinition) >= threshold;
+    const pattern = new RegExp(`export const ${schemaName} = `);
+    if (pattern.test(codeWithoutJsdoc)) {
+      let schemaBody = codeWithoutJsdoc.replace(pattern, "");
+      if (useAssertion) {
+        schemaBody = schemaBody.replace(/;$/, "");
+        return `${jsdoc}export const ${schemaName} = ${schemaBody} as unknown as z.ZodType<${typeName}>;`;
+      }
+      return `${jsdoc}export const ${schemaName}: z.ZodType<${typeName}> = ${schemaBody}`;
+    }
+    return code;
+  }
+  /**
+   * Type guard to check if a value is a Record<string, unknown>
+   */
+  isRecordObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  /**
+   * Calculate the complexity of a schema for threshold comparison
+   * Complexity formula: properties + (nested levels * 10) + (array/union members * 2)
+   */
+  calculateSchemaComplexity(schema, depth = 0) {
+    if (!schema || typeof schema !== "object") {
+      return 0;
+    }
+    let complexity = depth * 10;
+    if (schema.$ref) {
+      return complexity + 5;
+    }
+    const properties = schema.properties;
+    if (this.isRecordObject(properties)) {
+      const propCount = Object.keys(properties).length;
+      complexity += propCount;
+      for (const prop of Object.values(properties)) {
+        if (this.isRecordObject(prop)) {
+          complexity += this.calculateSchemaComplexity(prop, depth + 1);
+        }
+      }
+    }
+    const allOf = schema.allOf;
+    if (Array.isArray(allOf)) {
+      complexity += allOf.length * 2;
+      for (const subSchema of allOf) {
+        if (this.isRecordObject(subSchema)) {
+          complexity += this.calculateSchemaComplexity(subSchema, depth + 1);
+        }
+      }
+    }
+    const oneOf = schema.oneOf;
+    if (Array.isArray(oneOf)) {
+      complexity += oneOf.length * 2;
+      for (const subSchema of oneOf) {
+        if (this.isRecordObject(subSchema)) {
+          complexity += this.calculateSchemaComplexity(subSchema, depth + 1);
+        }
+      }
+    }
+    const anyOf = schema.anyOf;
+    if (Array.isArray(anyOf)) {
+      complexity += anyOf.length * 2;
+      for (const subSchema of anyOf) {
+        if (this.isRecordObject(subSchema)) {
+          complexity += this.calculateSchemaComplexity(subSchema, depth + 1);
+        }
+      }
+    }
+    const items = schema.items;
+    if (this.isRecordObject(items)) {
+      complexity += 2;
+      complexity += this.calculateSchemaComplexity(items, depth + 1);
+    }
+    const additionalProps = schema.additionalProperties;
+    if (this.isRecordObject(additionalProps)) {
+      complexity += 2;
+      complexity += this.calculateSchemaComplexity(additionalProps, depth + 1);
+    }
+    return complexity;
+  }
+  /**
+   * Calculate relative import path from schema file to types file
+   */
+  calculateRelativeImportPath(fromPath, toPath) {
+    const fromDir = dirname(normalize(fromPath));
+    const toFile = normalize(toPath).replace(/\.[tj]s$/, "");
+    let relativePath = relative(fromDir, toFile);
+    if (!relativePath.startsWith(".") && !relativePath.startsWith("..")) {
+      relativePath = `./${relativePath}`;
+    }
+    return relativePath.replace(/\\/g, "/");
   }
   /**
    * Resolve options for a specific context (request or response)
@@ -1973,191 +1784,84 @@ var OpenApiGenerator = class {
     };
   }
   /**
-   * Analyze schema usage across the OpenAPI spec to determine if schemas
-   * are used in request, response, or both contexts
+   * Initialize schema usage map using core utilities with operation filtering
+   * This is a wrapper around core's analyzeSchemaUsage that adds operation filtering
    */
-  analyzeSchemaUsage() {
-    var _a, _b;
-    const requestSchemas = /* @__PURE__ */ new Set();
-    const responseSchemas = /* @__PURE__ */ new Set();
-    if (this.spec.paths) {
+  initializeSchemaUsage() {
+    var _a;
+    if (this.options.operationFilters && this.spec.paths) {
+      const requestSchemas = /* @__PURE__ */ new Set();
+      const responseSchemas = /* @__PURE__ */ new Set();
       for (const [path, pathItem] of Object.entries(this.spec.paths)) {
-        const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
-        for (const method of methods) {
+        if (!isOpenAPIPathItem(pathItem)) continue;
+        for (const method of HTTP_METHODS) {
           const operation = pathItem[method];
-          if (typeof operation !== "object" || !operation) continue;
+          if (!operation) continue;
           this.filterStats.totalOperations++;
           if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters, this.filterStats)) {
             continue;
           }
           this.filterStats.includedOperations++;
-          if ("requestBody" in operation && operation.requestBody && typeof operation.requestBody === "object" && "content" in operation.requestBody && operation.requestBody.content) {
-            for (const mediaType of Object.values(operation.requestBody.content)) {
-              if (mediaType && typeof mediaType === "object" && "schema" in mediaType && mediaType.schema) {
-                this.extractSchemaRefs(mediaType.schema, requestSchemas);
+          if (operation.requestBody && typeof operation.requestBody === "object") {
+            const reqBody = operation.requestBody;
+            if (reqBody.content && typeof reqBody.content === "object") {
+              for (const mediaType of Object.values(reqBody.content)) {
+                if (mediaType && typeof mediaType === "object" && "schema" in mediaType && mediaType.schema) {
+                  extractSchemaRefs(mediaType.schema, requestSchemas);
+                }
               }
             }
           }
-          if ("responses" in operation && operation.responses && typeof operation.responses === "object") {
+          if (operation.responses && typeof operation.responses === "object") {
             for (const response of Object.values(operation.responses)) {
               if (response && typeof response === "object" && "content" in response && response.content && typeof response.content === "object") {
                 for (const mediaType of Object.values(response.content)) {
                   if (mediaType && typeof mediaType === "object" && "schema" in mediaType && mediaType.schema) {
-                    this.extractSchemaRefs(mediaType.schema, responseSchemas);
+                    extractSchemaRefs(mediaType.schema, responseSchemas);
                   }
                 }
               }
             }
           }
-          if ("parameters" in operation && Array.isArray(operation.parameters)) {
+          if (operation.parameters && Array.isArray(operation.parameters)) {
             for (const param of operation.parameters) {
-              if (param && typeof param === "object" && "schema" in param && param.schema) {
-                this.extractSchemaRefs(param.schema, requestSchemas);
+              if (isResolvedParameter(param) && param.schema) {
+                extractSchemaRefs(param.schema, requestSchemas);
               }
             }
           }
         }
       }
-      this.expandTransitiveReferences(requestSchemas);
-      this.expandTransitiveReferences(responseSchemas);
-    }
-    if (!this.spec.paths || requestSchemas.size === 0 && responseSchemas.size === 0) {
-      for (const [name, schema] of Object.entries(((_a = this.spec.components) == null ? void 0 : _a.schemas) || {})) {
-        const hasReadOnly = this.hasReadOnlyProperties(schema);
-        const hasWriteOnly = this.hasWriteOnlyProperties(schema);
-        if (hasWriteOnly && !hasReadOnly) {
-          requestSchemas.add(name);
-        } else if (hasReadOnly && !hasWriteOnly) {
-          responseSchemas.add(name);
+      expandTransitiveReferences(requestSchemas, this.spec);
+      expandTransitiveReferences(responseSchemas, this.spec);
+      for (const [name] of Object.entries(((_a = this.spec.components) == null ? void 0 : _a.schemas) || {})) {
+        if (requestSchemas.has(name) && responseSchemas.has(name)) {
+          this.schemaUsageMap.set(name, "both");
+        } else if (requestSchemas.has(name)) {
+          this.schemaUsageMap.set(name, "request");
+        } else if (responseSchemas.has(name)) {
+          this.schemaUsageMap.set(name, "response");
         }
       }
-    }
-    for (const [name] of Object.entries(((_b = this.spec.components) == null ? void 0 : _b.schemas) || {})) {
-      if (requestSchemas.has(name) && responseSchemas.has(name)) {
+      const circularSchemas = detectCircularReferences(this.spec);
+      for (const name of circularSchemas) {
         this.schemaUsageMap.set(name, "both");
-      } else if (requestSchemas.has(name)) {
-        this.schemaUsageMap.set(name, "request");
-      } else if (responseSchemas.has(name)) {
-        this.schemaUsageMap.set(name, "response");
-      }
-    }
-    this.detectCircularReferences();
-  }
-  /**
-   * Expand a set of schemas to include all transitively referenced schemas
-   */
-  expandTransitiveReferences(schemas) {
-    var _a, _b;
-    const toProcess = Array.from(schemas);
-    const processed = /* @__PURE__ */ new Set();
-    while (toProcess.length > 0) {
-      const schemaName = toProcess.pop();
-      if (!schemaName || processed.has(schemaName)) continue;
-      processed.add(schemaName);
-      const schema = (_b = (_a = this.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[schemaName];
-      if (schema) {
-        const refs = /* @__PURE__ */ new Set();
-        this.extractSchemaRefs(schema, refs);
-        for (const ref of refs) {
-          if (!schemas.has(ref)) {
-            schemas.add(ref);
-            toProcess.push(ref);
-          }
-        }
-      }
-    }
-  }
-  /**
-   * Extract schema names from $ref and nested structures
-   */
-  extractSchemaRefs(schema, refs) {
-    if (!schema) return;
-    if (schema.$ref) {
-      const refName = resolveRef(schema.$ref);
-      refs.add(refName);
-    }
-    if (schema.allOf) {
-      for (const subSchema of schema.allOf) {
-        this.extractSchemaRefs(subSchema, refs);
-      }
-    }
-    if (schema.oneOf) {
-      for (const subSchema of schema.oneOf) {
-        this.extractSchemaRefs(subSchema, refs);
-      }
-    }
-    if (schema.anyOf) {
-      for (const subSchema of schema.anyOf) {
-        this.extractSchemaRefs(subSchema, refs);
-      }
-    }
-    if (schema.items) {
-      this.extractSchemaRefs(schema.items, refs);
-    }
-    if (schema.properties) {
-      for (const prop of Object.values(schema.properties)) {
-        this.extractSchemaRefs(prop, refs);
-      }
-    }
-  }
-  /**
-   * Check if schema has readOnly properties
-   */
-  hasReadOnlyProperties(schema) {
-    if (schema.readOnly) return true;
-    if (schema.properties) {
-      for (const prop of Object.values(schema.properties)) {
-        if (this.hasReadOnlyProperties(prop)) return true;
       }
-    }
-    return false;
-  }
-  /**
-   * Check if schema has writeOnly properties
-   */
-  hasWriteOnlyProperties(schema) {
-    if (schema.writeOnly) return true;
-    if (schema.properties) {
-      for (const prop of Object.values(schema.properties)) {
-        if (this.hasWriteOnlyProperties(prop)) return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Detect circular references and mark them as "both" context for safety
-   */
-  detectCircularReferences() {
-    var _a;
-    const visited = /* @__PURE__ */ new Set();
-    const recursionStack = /* @__PURE__ */ new Set();
-    const detectCycle = (name) => {
-      var _a2, _b;
-      if (recursionStack.has(name)) {
-        return true;
-      }
-      if (visited.has(name)) {
-        return false;
-      }
-      visited.add(name);
-      recursionStack.add(name);
-      const schema = (_b = (_a2 = this.spec.components) == null ? void 0 : _a2.schemas) == null ? void 0 : _b[name];
-      if (schema) {
-        const refs = /* @__PURE__ */ new Set();
-        this.extractSchemaRefs(schema, refs);
-        for (const ref of refs) {
-          if (detectCycle(ref)) {
-            this.schemaUsageMap.set(name, "both");
-            recursionStack.delete(name);
-            return true;
+    } else {
+      const analysis = analyzeSchemaUsage(this.spec);
+      this.schemaUsageMap = analysis.usageMap;
+      if (this.spec.paths) {
+        for (const pathItem of Object.values(this.spec.paths)) {
+          if (!isOpenAPIPathItem(pathItem)) continue;
+          for (const method of HTTP_METHODS) {
+            const operation = pathItem[method];
+            if (typeof operation === "object" && operation) {
+              this.filterStats.totalOperations++;
+              this.filterStats.includedOperations++;
+            }
           }
         }
       }
-      recursionStack.delete(name);
-      return false;
-    };
-    for (const name of Object.keys(((_a = this.spec.components) == null ? void 0 : _a.schemas) || {})) {
-      detectCycle(name);
     }
   }
   /**
@@ -2190,7 +1894,7 @@ var OpenApiGenerator = class {
    */
   validateSchemaRefs(schemaName, schema, allSchemas, path = "") {
     if (schema.$ref) {
-      const refName = resolveRef(schema.$ref);
+      const refName = resolveRefName2(schema.$ref);
       if (!allSchemas.includes(refName)) {
         throw new SpecValidationError(
           `Invalid reference${path ? ` at '${path}'` : ""}: '${schema.$ref}' points to non-existent schema '${refName}'`,
@@ -2239,7 +1943,7 @@ var OpenApiGenerator = class {
     const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
     if (schema.enum) {
       const jsdoc2 = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      const strippedName2 = stripPrefix(name, this.options.stripSchemaPrefix);
+      const strippedName2 = stripPrefix2(name, this.options.stripSchemaPrefix);
       const { schemaCode, typeCode } = generateEnum(strippedName2, schema.enum, {
         prefix: this.options.prefix,
         suffix: this.options.suffix
@@ -2249,11 +1953,11 @@ ${typeCode}`;
       this.schemas.set(name, enumSchemaCode);
       return;
     }
-    const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
-    const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
-    const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
+    const strippedName = stripPrefix2(name, this.options.stripSchemaPrefix);
+    const schemaName = `${toCamelCase3(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+    let jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
     if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref) {
-      const refName = resolveRef(schema.allOf[0].$ref);
+      const refName = resolveRefName2(schema.allOf[0].$ref);
       (_a = this.schemaDependencies.get(name)) == null ? void 0 : _a.add(refName);
     }
     this.propertyGenerator = new PropertyGenerator({
@@ -2271,9 +1975,26 @@ ${typeCode}`;
       },
       stripSchemaPrefix: this.options.stripSchemaPrefix,
       dateTimeValidation: this.dateTimeValidation,
-      patternCache: this.patternCache
+      patternCache: this.patternCache,
+      separateTypesFile: this.separateSchemasMode
     });
+    this.propertyGenerator.setCircularDependencies(this.circularDependencies);
+    this.propertyGenerator.clearAllOfConflicts();
     const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, true);
+    const allOfConflicts = this.propertyGenerator.getAllOfConflicts();
+    if (allOfConflicts.length > 0) {
+      this.allOfConflictCount += allOfConflicts.length;
+      const conflictWarning = this.generateConflictJSDoc(allOfConflicts);
+      if (jsdoc) {
+        jsdoc = jsdoc.replace(/ \*\/\n$/, `
+${conflictWarning} */
+`);
+      } else {
+        jsdoc = `/**
+${conflictWarning} */
+`;
+      }
+    }
     const zodSchemaCode = `${jsdoc}export const ${schemaName} = ${zodSchema};`;
     if (zodSchema.includes("z.discriminatedUnion(")) {
       const match = zodSchema.match(/z\.discriminatedUnion\([^,]+,\s*\[([^\]]+)\]/);
@@ -2299,9 +2020,8 @@ ${typeCode}`;
       return;
     }
     for (const [path, pathItem] of Object.entries(this.spec.paths)) {
-      if (!pathItem || typeof pathItem !== "object") continue;
-      const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
-      for (const method of methods) {
+      if (!isOpenAPIPathItem(pathItem)) continue;
+      for (const method of HTTP_METHODS) {
         const operation = pathItem[method];
         if (!operation) continue;
         if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
@@ -2309,18 +2029,18 @@ ${typeCode}`;
         }
         const allParams = mergeParameters(pathItem.parameters, operation.parameters, this.spec);
         const queryParams = allParams.filter(
-          (param) => param && typeof param === "object" && param.in === "query"
+          (param) => isResolvedParameter(param) && param.in === "query"
         );
         if (queryParams.length === 0) {
           continue;
         }
-        let pascalOperationId;
-        if (operation.operationId) {
-          pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
-        } else {
-          const strippedPath = stripPathPrefix(path, this.options.stripPathPrefix);
-          pascalOperationId = this.generateMethodNameFromPath(method, strippedPath);
-        }
+        const strippedPath = stripPathPrefix(path, this.options.stripPathPrefix);
+        const pascalOperationId = getOperationName(
+          operation.operationId,
+          method,
+          strippedPath,
+          this.options.useOperationId
+        );
         const schemaName = `${pascalOperationId}QueryParams`;
         if (!this.schemaDependencies.has(schemaName)) {
           this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
@@ -2350,7 +2070,7 @@ ${typeCode}`;
             required.push(paramName);
           }
           if (paramSchema.$ref) {
-            const refName = resolveRef(paramSchema.$ref);
+            const refName = resolveRefName2(paramSchema.$ref);
             (_a = this.schemaDependencies.get(schemaName)) == null ? void 0 : _a.add(refName);
           }
         }
@@ -2365,9 +2085,7 @@ ${typeCode}`;
 ${propsCode}
 })`;
         const operationName = pascalOperationId;
-        const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
-        const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
-        const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}QueryParamsSchema`;
+        const camelCaseSchemaName = `${toCamelCase3(operationName, { prefix: this.options.prefix, suffix: this.options.suffix })}QueryParamsSchema`;
         const jsdocOperationName = operation.operationId || `${method.toUpperCase()} ${path}`;
         const jsdoc = `/**
  * Query parameters for ${jsdocOperationName}
@@ -2379,35 +2097,6 @@ ${propsCode}
       }
     }
   }
-  /**
-   * Generate a PascalCase method name from HTTP method and path
-   * Used as fallback when operationId is not available
-   * @internal
-   */
-  generateMethodNameFromPath(method, path) {
-    const segments = path.split("/").filter(Boolean).map((segment) => {
-      if (segment.startsWith("{") && segment.endsWith("}")) {
-        const paramName = segment.slice(1, -1);
-        return `By${this.capitalizeSegment(paramName)}`;
-      }
-      return this.capitalizeSegment(segment);
-    }).join("");
-    const capitalizedMethod = method.charAt(0).toUpperCase() + method.slice(1).toLowerCase();
-    return `${capitalizedMethod}${segments}`;
-  }
-  /**
-   * Capitalizes a path segment, handling special characters like dashes, underscores, and dots
-   * @internal
-   */
-  capitalizeSegment(str) {
-    if (str.includes("-") || str.includes("_") || str.includes(".")) {
-      return str.split(/[-_.]/).map((part) => {
-        if (!part) return "";
-        return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-      }).join("");
-    }
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
   /**
    * Check if a header should be ignored based on filter patterns
    * @internal
@@ -2423,7 +2112,7 @@ ${propsCode}
     const headerLower = headerName.toLowerCase();
     return ignorePatterns.some((pattern) => {
       const patternLower = pattern.toLowerCase();
-      return minimatch3(headerLower, patternLower);
+      return minimatch(headerLower, patternLower);
     });
   }
   /**
@@ -2436,9 +2125,8 @@ ${propsCode}
       return;
     }
     for (const [path, pathItem] of Object.entries(this.spec.paths)) {
-      if (!pathItem || typeof pathItem !== "object") continue;
-      const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
-      for (const method of methods) {
+      if (!isOpenAPIPathItem(pathItem)) continue;
+      for (const method of HTTP_METHODS) {
         const operation = pathItem[method];
         if (!operation) continue;
         if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
@@ -2446,18 +2134,18 @@ ${propsCode}
         }
         const allParams = mergeParameters(pathItem.parameters, operation.parameters, this.spec);
         const headerParams = allParams.filter(
-          (param) => param && typeof param === "object" && param.in === "header" && !this.shouldIgnoreHeader(param.name)
+          (param) => isResolvedParameter(param) && param.in === "header" && !this.shouldIgnoreHeader(param.name)
         );
         if (headerParams.length === 0) {
           continue;
         }
-        let pascalOperationId;
-        if (operation.operationId) {
-          pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
-        } else {
-          const strippedPath = stripPathPrefix(path, this.options.stripPathPrefix);
-          pascalOperationId = this.generateMethodNameFromPath(method, strippedPath);
-        }
+        const strippedPath = stripPathPrefix(path, this.options.stripPathPrefix);
+        const pascalOperationId = getOperationName(
+          operation.operationId,
+          method,
+          strippedPath,
+          this.options.useOperationId
+        );
         const schemaName = `${pascalOperationId}HeaderParams`;
         if (!this.schemaDependencies.has(schemaName)) {
           this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
@@ -2476,7 +2164,7 @@ ${propsCode}
           zodType = `${zodType}.optional()`;
           properties[paramName] = zodType;
           if (paramSchema.$ref) {
-            const refName = resolveRef(paramSchema.$ref);
+            const refName = resolveRefName2(paramSchema.$ref);
             (_a = this.schemaDependencies.get(schemaName)) == null ? void 0 : _a.add(refName);
           }
         }
@@ -2491,9 +2179,7 @@ ${propsCode}
 ${propsCode}
 })`;
         const operationName = pascalOperationId;
-        const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
-        const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
-        const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}HeaderParamsSchema`;
+        const camelCaseSchemaName = `${toCamelCase3(operationName, { prefix: this.options.prefix, suffix: this.options.suffix })}HeaderParamsSchema`;
         const jsdocOperationName = operation.operationId || `${method.toUpperCase()} ${path}`;
         const jsdoc = `/**
  * Header parameters for ${jsdocOperationName}
@@ -2510,9 +2196,9 @@ ${propsCode}
    */
   generateQueryParamType(schema, param) {
     if (schema.$ref) {
-      const refName = resolveRef(schema.$ref);
-      const strippedRefName = stripPrefix(refName, this.options.stripSchemaPrefix);
-      const schemaName = toCamelCase(strippedRefName, { prefix: this.options.prefix, suffix: this.options.suffix });
+      const refName = resolveRefName2(schema.$ref);
+      const strippedRefName = stripPrefix2(refName, this.options.stripSchemaPrefix);
+      const schemaName = toCamelCase3(strippedRefName, { prefix: this.options.prefix, suffix: this.options.suffix });
       return `${schemaName}Schema`;
     }
     if (schema.enum) {
@@ -2529,7 +2215,7 @@ ${propsCode}
         if (typeof v === "string") {
           return `z.literal("${v}")`;
         }
-        return `z.literal(${v})`;
+        return `z.literal(${String(v)})`;
       }).join(", ");
       return `z.union([${literalValues}])`;
     }
@@ -2609,17 +2295,23 @@ ${propsCode}
         return;
       }
       const deps = this.schemaDependencies.get(name);
+      let dependsOnCircular = false;
       if (deps && deps.size > 0) {
         for (const dep of deps) {
           if (this.schemas.has(dep) || this.types.has(dep)) {
             visit(dep);
+            if (circularDeps.has(dep)) {
+              dependsOnCircular = true;
+            }
           }
         }
       }
       visiting.delete(name);
       visited.add(name);
-      if (!circularDeps.has(name)) {
+      if (!circularDeps.has(name) && !dependsOnCircular) {
         sorted.push(name);
+      } else if (dependsOnCircular && !circularDeps.has(name)) {
+        circularDeps.add(name);
       }
     };
     const allNames = /* @__PURE__ */ new Set([...this.schemas.keys(), ...this.types.keys()]);
@@ -2627,9 +2319,8 @@ ${propsCode}
       visit(name);
     }
     for (const name of circularDeps) {
-      if (!visited.has(name)) {
+      if (!sorted.includes(name)) {
         sorted.push(name);
-        visited.add(name);
       }
     }
     return [...sorted, ...aliases];
@@ -2656,7 +2347,8 @@ ${propsCode}
       `//   Total schemas: ${stats.totalSchemas}`,
       `//   Circular references: ${stats.withCircularRefs}`,
       `//   Discriminated unions: ${stats.withDiscriminators}`,
-      `//   With constraints: ${stats.withConstraints}`
+      `//   With constraints: ${stats.withConstraints}`,
+      `//   AllOf conflicts: ${this.allOfConflictCount}`
     ];
     if (this.options.operationFilters && this.filterStats.totalOperations > 0) {
       output.push("//");
@@ -2668,6 +2360,106 @@ ${propsCode}
     output.push(`//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
     return output;
   }
+  /**
+   * Pre-analyze schemas to detect circular dependencies before code generation.
+   * This allows the property generator to use z.lazy() for forward references.
+   */
+  analyzeCircularDependencies() {
+    var _a;
+    if (!((_a = this.spec.components) == null ? void 0 : _a.schemas)) return;
+    const dependencies = /* @__PURE__ */ new Map();
+    const collectDependencies = (name, schema, visited2 = /* @__PURE__ */ new Set()) => {
+      if (visited2.has(name)) return /* @__PURE__ */ new Set();
+      visited2.add(name);
+      const deps = /* @__PURE__ */ new Set();
+      if (schema.$ref) {
+        const refName = resolveRefName2(schema.$ref);
+        deps.add(refName);
+      }
+      if (schema.allOf) {
+        for (const item of schema.allOf) {
+          const itemDeps = collectDependencies(`${name}_allOf`, item, new Set(visited2));
+          for (const dep of itemDeps) deps.add(dep);
+        }
+      }
+      if (schema.oneOf) {
+        for (const item of schema.oneOf) {
+          const itemDeps = collectDependencies(`${name}_oneOf`, item, new Set(visited2));
+          for (const dep of itemDeps) deps.add(dep);
+        }
+      }
+      if (schema.anyOf) {
+        for (const item of schema.anyOf) {
+          const itemDeps = collectDependencies(`${name}_anyOf`, item, new Set(visited2));
+          for (const dep of itemDeps) deps.add(dep);
+        }
+      }
+      if (schema.properties) {
+        for (const propSchema of Object.values(schema.properties)) {
+          const propDeps = collectDependencies(`${name}_prop`, propSchema, new Set(visited2));
+          for (const dep of propDeps) deps.add(dep);
+        }
+      }
+      if (schema.items) {
+        const itemDeps = collectDependencies(`${name}_items`, schema.items, new Set(visited2));
+        for (const dep of itemDeps) deps.add(dep);
+      }
+      if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        const addDeps = collectDependencies(`${name}_additional`, schema.additionalProperties, new Set(visited2));
+        for (const dep of addDeps) deps.add(dep);
+      }
+      return deps;
+    };
+    for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
+      if (this.options.operationFilters && this.schemaUsageMap.size > 0 && !this.schemaUsageMap.has(name)) {
+        continue;
+      }
+      dependencies.set(name, collectDependencies(name, schema));
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const detectCircular = (name, path = []) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        const cycleStart = path.indexOf(name);
+        if (cycleStart >= 0) {
+          for (let i = cycleStart; i < path.length; i++) {
+            this.circularDependencies.add(path[i]);
+          }
+        }
+        this.circularDependencies.add(name);
+        return;
+      }
+      visiting.add(name);
+      path.push(name);
+      const deps = dependencies.get(name);
+      if (deps) {
+        for (const dep of deps) {
+          if (dependencies.has(dep)) {
+            detectCircular(dep, [...path]);
+          }
+        }
+      }
+      visiting.delete(name);
+      visited.add(name);
+    };
+    for (const name of dependencies.keys()) {
+      detectCircular(name, []);
+    }
+  }
+  /**
+   * Generate JSDoc warning for allOf conflicts
+   * @param conflicts Array of conflict description strings
+   * @returns JSDoc formatted warning string
+   */
+  generateConflictJSDoc(conflicts) {
+    const lines = [" * @warning allOf property conflicts detected:"];
+    for (const conflict of conflicts) {
+      lines.push(` * - ${conflict}`);
+    }
+    return `${lines.join("\n")}
+`;
+  }
 };
 
 // src/types.ts
@@ -2681,8 +2473,10 @@ export {
   FileOperationError,
   GeneratorError,
   OpenApiGenerator,
-  SchemaGenerationError,
-  SpecValidationError,
+  PropertyGenerator,
+  SchemaGenerationError2 as SchemaGenerationError,
+  SpecValidationError2 as SpecValidationError,
+  buildDateTimeValidation,
   defineConfig
 };
 //# sourceMappingURL=index.mjs.map