@cerios/openapi-to-zod 1.3.1 → 1.4.0

package/dist/internal.mjs

@@ -135,6 +135,1502 @@ function getBatchExitCode(summary) {
   return summary.failed > 0 ? 1 : 0;
 }
 
+// src/utils/lru-cache.ts
+var LRUCache = class {
+  constructor(maxSize) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get capacity() {
+    return this.maxSize;
+  }
+  get(key) {
+    if (!this.cache.has(key)) return void 0;
+    const value = this.cache.get(key);
+    if (value === void 0) return void 0;
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+
+// src/utils/name-utils.ts
+function sanitizeIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9._\-\s]+/g, "_");
+}
+function toCamelCase(str, options) {
+  const sanitized = sanitizeIdentifier(str);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let name;
+  if (words.length === 0) {
+    name = str.charAt(0).toLowerCase() + str.slice(1);
+  } else if (words.length === 1) {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  } else {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  if (options == null ? void 0 : options.prefix) {
+    const prefix = options.prefix.charAt(0).toLowerCase() + options.prefix.slice(1);
+    name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
+  }
+  if (options == null ? void 0 : options.suffix) {
+    const suffix = options.suffix.charAt(0).toUpperCase() + options.suffix.slice(1);
+    name = name + suffix;
+  }
+  return name;
+}
+function toPascalCase(str) {
+  const stringValue = String(str);
+  const isAlreadyValidCase = /^[a-zA-Z][a-zA-Z0-9]*$/.test(stringValue);
+  if (isAlreadyValidCase) {
+    return stringValue.charAt(0).toUpperCase() + stringValue.slice(1);
+  }
+  const sanitized = sanitizeIdentifier(stringValue);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let result;
+  if (words.length === 0) {
+    result = "Value";
+  } else {
+    result = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  if (/^\d/.test(result)) {
+    result = `N${result}`;
+  }
+  if (!result || /^_+$/.test(result)) {
+    return "Value";
+  }
+  return result;
+}
+function resolveRef(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1];
+}
+
+// src/utils/pattern-utils.ts
+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/utils/string-utils.ts
+function escapeDescription(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function escapePattern(str) {
+  return str.replace(/(?<!\\)\//g, "\\/");
+}
+function escapeJSDoc(str) {
+  return str.replace(/\*\//g, "*\\/");
+}
+function wrapNullable(validation, isNullable2) {
+  return isNullable2 ? `${validation}.nullable()` : validation;
+}
+function isNullable(schema, defaultNullable = false) {
+  if (schema.nullable === true) {
+    return true;
+  }
+  if (schema.nullable === false) {
+    return false;
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.includes("null");
+  }
+  return defaultNullable;
+}
+function getPrimaryType(schema) {
+  if (Array.isArray(schema.type)) {
+    const nonNullType = schema.type.find((t) => t !== "null");
+    return nonNullType;
+  }
+  return schema.type;
+}
+function hasMultipleTypes(schema) {
+  if (Array.isArray(schema.type)) {
+    const nonNullTypes = schema.type.filter((t) => t !== "null");
+    return nonNullTypes.length > 1;
+  }
+  return false;
+}
+function addDescription(validation, description, useDescribe) {
+  if (!description || !useDescribe) return validation;
+  const escapedDesc = escapeDescription(description);
+  return `${validation}.describe("${escapedDesc}")`;
+}
+
+// src/validators/array-validator.ts
+function generateArrayValidation(schema, context) {
+  var _a;
+  let validation;
+  if (schema.prefixItems && schema.prefixItems.length > 0) {
+    const tupleItems = schema.prefixItems.map((item) => context.generatePropertySchema(item, context.currentSchema));
+    validation = `z.tuple([${tupleItems.join(", ")}])`;
+    if (schema.items) {
+      const restSchema = context.generatePropertySchema(schema.items, context.currentSchema);
+      validation += `.rest(${restSchema})`;
+    } else if (schema.unevaluatedItems && typeof schema.unevaluatedItems === "object") {
+      const restSchema = context.generatePropertySchema(schema.unevaluatedItems, context.currentSchema);
+      validation += `.rest(${restSchema})`;
+    }
+  } else if (schema.items) {
+    const itemSchema = context.generatePropertySchema(schema.items, context.currentSchema);
+    validation = `z.array(${itemSchema})`;
+    if (schema.minItems !== void 0) {
+      validation += `.min(${schema.minItems})`;
+    }
+    if (schema.maxItems !== void 0) {
+      validation += `.max(${schema.maxItems})`;
+    }
+    if (schema.uniqueItems === true) {
+      validation += `.refine((items) => new Set(items).size === items.length, { message: "Array items must be unique" })`;
+    }
+  } else {
+    validation = "z.array(z.unknown())";
+  }
+  if (schema.contains) {
+    const containsSchema = context.generatePropertySchema(schema.contains, context.currentSchema);
+    const minCount = (_a = schema.minContains) != null ? _a : 1;
+    const maxCount = schema.maxContains;
+    if (maxCount !== void 0) {
+      validation += `.refine((arr) => { const matches = arr.filter(item => ${containsSchema}.safeParse(item).success); return matches.length >= ${minCount} && matches.length <= ${maxCount}; }, { message: "Array must contain between ${minCount} and ${maxCount} items matching the schema" })`;
+    } else {
+      validation += `.refine((arr) => arr.filter(item => ${containsSchema}.safeParse(item).success).length >= ${minCount}, { message: "Array must contain at least ${minCount} item(s) matching the schema" })`;
+    }
+  }
+  if (schema.unevaluatedItems === false && schema.prefixItems && schema.prefixItems.length > 0 && !schema.items) {
+    const prefixCount = schema.prefixItems.length;
+    validation += `.refine((arr) => arr.length <= ${prefixCount}, { message: "No unevaluated items allowed beyond prefix items" })`;
+  }
+  return addDescription(validation, schema.description, context.useDescribe);
+}
+
+// src/validators/composition-validator.ts
+function isDiscriminatorRequired(schemas, discriminator, context) {
+  const invalidSchemas = [];
+  for (const schema of schemas) {
+    const resolved = resolveSchema(schema, context);
+    const required = resolved.required || [];
+    if (!required.includes(discriminator)) {
+      const schemaName = schema.$ref ? schema.$ref.split("/").pop() || "inline" : "inline";
+      invalidSchemas.push(schemaName);
+    }
+  }
+  return {
+    valid: invalidSchemas.length === 0,
+    invalidSchemas
+  };
+}
+function generateUnion(schemas, discriminator, isNullable2, context, options, currentSchema) {
+  if (schemas.length === 0) {
+    console.warn(
+      "[openapi-to-zod] Warning: Empty oneOf/anyOf array encountered. This is likely a malformed OpenAPI spec. Generating z.never() as fallback."
+    );
+    return wrapNullable(
+      'z.never().describe("Empty oneOf/anyOf in OpenAPI spec - no valid schema defined")',
+      isNullable2
+    );
+  }
+  if (schemas.length === 1) {
+    let singleSchema = context.generatePropertySchema(schemas[0], currentSchema, false, true);
+    if ((options == null ? void 0 : options.passthrough) && !singleSchema.includes(".catchall(")) {
+      singleSchema = `${singleSchema}.catchall(z.unknown())`;
+    }
+    return wrapNullable(singleSchema, isNullable2);
+  }
+  if (discriminator) {
+    let resolvedSchemas = schemas;
+    if ((options == null ? void 0 : options.discriminatorMapping) && context.resolveDiscriminatorMapping) {
+      resolvedSchemas = context.resolveDiscriminatorMapping(options.discriminatorMapping, schemas);
+    }
+    const discriminatorCheck = isDiscriminatorRequired(resolvedSchemas, discriminator, context);
+    if (!discriminatorCheck.valid) {
+      console.warn(
+        `[openapi-to-zod] Warning: Discriminator "${discriminator}" is not required in schemas: ${discriminatorCheck.invalidSchemas.join(", ")}. Falling back to z.union() instead of z.discriminatedUnion().`
+      );
+      let schemaStrings3 = resolvedSchemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
+      if (options == null ? void 0 : options.passthrough) {
+        schemaStrings3 = schemaStrings3.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
+      }
+      const fallbackDescription = `Discriminator "${discriminator}" is optional in some schemas (${discriminatorCheck.invalidSchemas.join(", ")}), using z.union() instead of z.discriminatedUnion()`;
+      const union3 = `z.union([${schemaStrings3.join(", ")}]).describe("${fallbackDescription}")`;
+      return wrapNullable(union3, isNullable2);
+    }
+    let schemaStrings2 = resolvedSchemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
+    if (options == null ? void 0 : options.passthrough) {
+      schemaStrings2 = schemaStrings2.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
+    }
+    const union2 = `z.discriminatedUnion("${discriminator}", [${schemaStrings2.join(", ")}])`;
+    return wrapNullable(union2, isNullable2);
+  }
+  let schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
+  if (options == null ? void 0 : options.passthrough) {
+    schemaStrings = schemaStrings.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
+  }
+  const union = `z.union([${schemaStrings.join(", ")}])`;
+  return wrapNullable(union, isNullable2);
+}
+function resolveSchema(schema, context) {
+  if (schema.$ref && context.resolveSchemaRef) {
+    const resolved = context.resolveSchemaRef(schema.$ref);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return schema;
+}
+function collectProperties(schema, context) {
+  const resolved = resolveSchema(schema, context);
+  const props = /* @__PURE__ */ new Map();
+  const sourceName = schema.$ref ? schema.$ref.split("/").pop() || "unknown" : "inline";
+  if (resolved.properties) {
+    for (const [key, value] of Object.entries(resolved.properties)) {
+      props.set(key, { schema: value, source: sourceName });
+    }
+  }
+  if (resolved.allOf) {
+    for (const subSchema of resolved.allOf) {
+      const subProps = collectProperties(subSchema, context);
+      for (const [key, value] of subProps) {
+        if (!props.has(key)) {
+          props.set(key, value);
+        }
+      }
+    }
+  }
+  return props;
+}
+function schemasMatch(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function detectConflictingProperties(schemas, context) {
+  const conflicts = [];
+  const propertyMap = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const schemaProps = collectProperties(schema, context);
+    for (const [propName, propInfo] of schemaProps) {
+      const existing = propertyMap.get(propName);
+      if (existing) {
+        if (!schemasMatch(existing.schema, propInfo.schema)) {
+          conflicts.push(
+            `Property "${propName}" has conflicting definitions in ${existing.source} and ${propInfo.source}`
+          );
+        }
+      } else {
+        propertyMap.set(propName, propInfo);
+      }
+    }
+  }
+  return conflicts;
+}
+function generateAllOf(schemas, isNullable2, context, currentSchema) {
+  if (schemas.length === 1) {
+    const singleSchema = context.generatePropertySchema(schemas[0], currentSchema, false, true);
+    return wrapNullable(singleSchema, isNullable2);
+  }
+  const conflicts = detectConflictingProperties(schemas, context);
+  let conflictDescription = "";
+  if (conflicts.length > 0) {
+    for (const conflict of conflicts) {
+      console.warn(`[openapi-to-zod] Warning: allOf composition conflict - ${conflict}`);
+    }
+    conflictDescription = `allOf property conflicts detected: ${conflicts.join("; ")}`;
+  }
+  const allObjects = schemas.every((s) => s.type === "object" || s.properties || s.$ref || s.allOf);
+  let result;
+  if (allObjects) {
+    let merged = context.generatePropertySchema(schemas[0], currentSchema, false, true);
+    for (let i = 1; i < schemas.length; i++) {
+      const schema = schemas[i];
+      if (schema.$ref) {
+        const refSchema = context.generatePropertySchema(schema, currentSchema, false, true);
+        merged = `${merged}.extend(${refSchema}.shape)`;
+      } else if (context.generateInlineObjectShape && (schema.properties || schema.type === "object")) {
+        const inlineShape = context.generateInlineObjectShape(schema, currentSchema);
+        merged = `${merged}.extend(${inlineShape})`;
+      } else {
+        const schemaString = context.generatePropertySchema(schema, currentSchema, false, true);
+        merged = `${merged}.extend(${schemaString}.shape)`;
+      }
+    }
+    result = merged;
+  } else {
+    const schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema, false, true));
+    let merged = schemaStrings[0];
+    for (let i = 1; i < schemaStrings.length; i++) {
+      merged = `${merged}.and(${schemaStrings[i]})`;
+    }
+    result = merged;
+  }
+  if (conflictDescription) {
+    result = `${result}.describe("${conflictDescription}")`;
+  }
+  return wrapNullable(result, isNullable2);
+}
+
+// src/validators/number-validator.ts
+function generateNumberValidation(schema, isInt, useDescribe) {
+  let validation = isInt ? "z.number().int()" : "z.number()";
+  if (schema.minimum !== void 0) {
+    const isExclusive = schema.exclusiveMinimum === true;
+    validation += isExclusive ? `.gt(${schema.minimum})` : `.gte(${schema.minimum})`;
+  } else if (typeof schema.exclusiveMinimum === "number") {
+    validation += `.gt(${schema.exclusiveMinimum})`;
+  }
+  if (schema.maximum !== void 0) {
+    const isExclusive = schema.exclusiveMaximum === true;
+    validation += isExclusive ? `.lt(${schema.maximum})` : `.lte(${schema.maximum})`;
+  } else if (typeof schema.exclusiveMaximum === "number") {
+    validation += `.lt(${schema.exclusiveMaximum})`;
+  }
+  if (schema.multipleOf !== void 0) {
+    validation += `.multipleOf(${schema.multipleOf})`;
+  }
+  return addDescription(validation, schema.description, useDescribe);
+}
+
+// src/generators/jsdoc-generator.ts
+function generateJSDoc(schema, name, options = { includeDescriptions: true }) {
+  if (!schema || typeof schema !== "object") {
+    return "";
+  }
+  if (!options.includeDescriptions) {
+    if (schema.deprecated) {
+      return "/** @deprecated */\n";
+    }
+    return "";
+  }
+  if (!schema.description && !schema.title && !schema.deprecated && !schema.examples && schema.example === void 0) {
+    return "";
+  }
+  const parts = [];
+  if (schema.title && typeof schema.title === "string" && (!name || schema.title !== name)) {
+    const sanitizedTitle = escapeJSDoc(schema.title).replace(/@/g, "\\@");
+    parts.push(sanitizedTitle);
+  }
+  if (schema.description && typeof schema.description === "string") {
+    const sanitizedDesc = escapeJSDoc(schema.description).replace(/@/g, "\\@").replace(/\*\//g, "*\\/");
+    parts.push(sanitizedDesc);
+  }
+  if (schema.examples && Array.isArray(schema.examples) && schema.examples.length > 0) {
+    try {
+      const examplesStr = schema.examples.map((ex) => JSON.stringify(ex)).join(", ");
+      parts.push(`@example ${examplesStr}`);
+    } catch (error) {
+      console.warn("Warning: Could not serialize schema examples", error);
+    }
+  } else if (schema.example !== void 0) {
+    try {
+      parts.push(`@example ${JSON.stringify(schema.example)}`);
+    } catch (error) {
+      console.warn("Warning: Could not serialize schema example", error);
+    }
+  }
+  if (schema.deprecated) {
+    parts.push("@deprecated");
+  }
+  if (parts.length === 0) {
+    return "";
+  }
+  const fullComment = parts.join(" ");
+  return `/** ${fullComment} */
+`;
+}
+
+// src/validators/conditional-validator.ts
+function generatePropertyAccess(propName) {
+  const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  return validIdentifier.test(propName) ? `obj.${propName}` : `obj["${propName}"]`;
+}
+function generateDependencies(schema, generatePropertySchema, currentSchema) {
+  if (!schema.dependencies) {
+    return "";
+  }
+  let result = "";
+  for (const [prop, dependency] of Object.entries(schema.dependencies)) {
+    if (Array.isArray(dependency)) {
+      if (dependency.length === 0) {
+        continue;
+      }
+      const propAccess = generatePropertyAccess(prop);
+      const checkLogic = dependency.map((p) => {
+        const pAccess = generatePropertyAccess(p);
+        return `if (${pAccess} === undefined) missing.push('${p}');`;
+      }).join("\n		");
+      result += `.superRefine((obj, ctx) => {
+				if (${propAccess} === undefined) return;
+				const missing: string[] = [];
+				${checkLogic}
+				if (missing.length > 0) {
+					ctx.addIssue({
+						code: "custom",
+						message: \`When '${prop}' is present, the following properties are required: \${missing.join(', ')}\`,
+						path: []
+					});
+				}
+			})`;
+    } else if (generatePropertySchema) {
+      const depSchema = { ...dependency, type: dependency.type || "object" };
+      const depSchemaValidation = generatePropertySchema(depSchema, currentSchema);
+      const propAccess = generatePropertyAccess(prop);
+      result += `.superRefine((obj, ctx) => {
+				if (${propAccess} === undefined) return;
+				const validation = ${depSchemaValidation}.safeParse(obj);
+				if (!validation.success) {
+					const errors = validation.error.issues.map(i => \`  - \${i.path.join('.')}: \${i.message}\`).join('\\n');
+					ctx.addIssue({
+						code: "custom",
+						message: \`When '${prop}' is present, object must satisfy additional constraints:\\n\${errors}\`,
+						path: []
+					});
+				}
+			})`;
+    }
+  }
+  return result;
+}
+function generateConditionalCheck(schema) {
+  const conditions = [];
+  if (schema.properties) {
+    for (const [prop, propSchema] of Object.entries(schema.properties)) {
+      const propAccess = generatePropertyAccess(prop);
+      if (propSchema.type) {
+        conditions.push(`typeof ${propAccess} === "${propSchema.type}"`);
+      }
+      if (propSchema.const !== void 0) {
+        const value = typeof propSchema.const === "string" ? `"${propSchema.const}"` : propSchema.const;
+        conditions.push(`${propAccess} === ${value}`);
+      }
+      if (propSchema.minimum !== void 0) {
+        conditions.push(`${propAccess} >= ${propSchema.minimum}`);
+      }
+      if (propSchema.maximum !== void 0) {
+        conditions.push(`${propAccess} <= ${propSchema.maximum}`);
+      }
+    }
+  }
+  if (schema.required) {
+    for (const prop of schema.required) {
+      conditions.push(`${generatePropertyAccess(prop)} !== undefined`);
+    }
+  }
+  return conditions.length > 0 ? conditions.join(" && ") : "true";
+}
+function generateConditionalValidation(schema) {
+  const checks = [];
+  if (schema.required) {
+    for (const prop of schema.required) {
+      checks.push(`${generatePropertyAccess(prop)} !== undefined`);
+    }
+  }
+  if (schema.properties) {
+    for (const [prop, propSchema] of Object.entries(schema.properties)) {
+      const propAccess = generatePropertyAccess(prop);
+      if (propSchema.minimum !== void 0) {
+        checks.push(`${propAccess} === undefined || ${propAccess} >= ${propSchema.minimum}`);
+      }
+      if (propSchema.maximum !== void 0) {
+        checks.push(`${propAccess} === undefined || ${propAccess} <= ${propSchema.maximum}`);
+      }
+    }
+  }
+  return checks.length > 0 ? checks.join(" && ") : "true";
+}
+function generateIfThenElse(schema) {
+  if (!schema.if || !schema.then && !schema.else) {
+    return "";
+  }
+  const ifCondition = generateConditionalCheck(schema.if);
+  if (schema.then && schema.else) {
+    const thenValidation = generateConditionalValidation(schema.then);
+    const elseValidation2 = generateConditionalValidation(schema.else);
+    const thenRequiredProps = schema.then.required || [];
+    const elseRequiredProps2 = schema.else.required || [];
+    return `.superRefine((obj, ctx) => {
+			const ifConditionMet = ${ifCondition};
+			if (ifConditionMet) {
+				// Then branch
+				const thenValid = ${thenValidation};
+				if (!thenValid) {
+					${thenRequiredProps.length > 0 ? `
+					const missingThenProps = ${JSON.stringify(thenRequiredProps)}.filter(p => obj[p] === undefined);
+					const message = missingThenProps.length > 0 
+						? \`When condition is met, required properties are missing: \${missingThenProps.join(', ')}\`
+						: "When condition is met, validation constraints failed";
+					` : `
+					const message = "When condition is met, validation constraints failed";
+					`}
+					ctx.addIssue({
+						code: "custom",
+						message: message,
+						path: []
+					});
+				}
+			} else {
+				// Else branch
+				const elseValid = ${elseValidation2};
+				if (!elseValid) {
+					${elseRequiredProps2.length > 0 ? `
+					const missingElseProps = ${JSON.stringify(elseRequiredProps2)}.filter(p => obj[p] === undefined);
+					const message = missingElseProps.length > 0 
+						? \`When condition is not met, required properties are missing: \${missingElseProps.join(', ')}\`
+						: "When condition is not met, validation constraints failed";
+					` : `
+					const message = "When condition is not met, validation constraints failed";
+					`}
+					ctx.addIssue({
+						code: "custom",
+						message: message,
+						path: []
+					});
+				}
+			}
+		})`;
+  }
+  if (schema.then) {
+    const thenValidation = generateConditionalValidation(schema.then);
+    const thenRequiredProps = schema.then.required || [];
+    return `.superRefine((obj, ctx) => {
+			const ifConditionMet = ${ifCondition};
+			if (ifConditionMet) {
+				const thenValid = ${thenValidation};
+				if (!thenValid) {
+					${thenRequiredProps.length > 0 ? `
+					const missingProps = ${JSON.stringify(thenRequiredProps)}.filter(p => obj[p] === undefined);
+					const message = missingProps.length > 0 
+						? \`When condition is met, required properties are missing: \${missingProps.join(', ')}\`
+						: "When condition is met, validation constraints failed";
+					` : `
+					const message = "When condition is met, validation constraints failed";
+					`}
+					ctx.addIssue({
+						code: "custom",
+						message: message,
+						path: []
+					});
+				}
+			}
+		})`;
+  }
+  if (!schema.else) return "";
+  const elseValidation = generateConditionalValidation(schema.else);
+  const elseRequiredProps = schema.else.required || [];
+  return `.superRefine((obj, ctx) => {
+		const ifConditionMet = ${ifCondition};
+		if (!ifConditionMet) {
+			const elseValid = ${elseValidation};
+			if (!elseValid) {
+				${elseRequiredProps.length > 0 ? `
+				const missingProps = ${JSON.stringify(elseRequiredProps)}.filter(p => obj[p] === undefined);
+				const message = missingProps.length > 0 
+					? \`When condition is not met, required properties are missing: \${missingProps.join(', ')}\`
+					: "When condition is not met, validation constraints failed";
+				` : `
+				const message = "When condition is not met, validation constraints failed";
+				`}
+				ctx.addIssue({
+					code: "custom",
+					message: message,
+					path: []
+				});
+			}
+		}
+	})`;
+}
+function generateDependentRequired(schema) {
+  if (!schema.dependentRequired) {
+    return "";
+  }
+  let result = "";
+  for (const [prop, requiredProps] of Object.entries(schema.dependentRequired)) {
+    if (requiredProps.length === 0) {
+      continue;
+    }
+    const propAccess = generatePropertyAccess(prop);
+    const checkLogic = requiredProps.map((rp) => {
+      const rpAccess = generatePropertyAccess(rp);
+      return `if (${rpAccess} === undefined) missing.push('${rp}');`;
+    }).join("\n		");
+    result += `.superRefine((obj, ctx) => {
+			if (${propAccess} === undefined) return;
+			const missing: string[] = [];
+			${checkLogic}
+			if (missing.length > 0) {
+				ctx.addIssue({
+					code: "custom",
+					message: \`When '${prop}' is present, the following properties are required: \${missing.join(', ')}\`,
+					path: []
+				});
+			}
+		})`;
+  }
+  return result;
+}
+
+// src/validators/object-validator.ts
+function needsQuoting(propName) {
+  const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  return !validIdentifier.test(propName);
+}
+function generatePropertyAccess2(propName) {
+  return needsQuoting(propName) ? `obj["${propName}"]` : `obj.${propName}`;
+}
+function generateObjectSchema(schema, context, currentSchema) {
+  const required = new Set(schema.required || []);
+  const properties = [];
+  if (schema.properties) {
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      if (!context.shouldIncludeProperty(propSchema)) {
+        continue;
+      }
+      const isRequired = required.has(propName);
+      const zodSchema = context.generatePropertySchema(propSchema, currentSchema);
+      const quotedPropName = needsQuoting(propName) ? `"${propName}"` : propName;
+      let propertyDef = `  ${quotedPropName}: ${zodSchema}`;
+      if (!isRequired) {
+        propertyDef += ".optional()";
+      }
+      const jsdoc = generateJSDoc(propSchema, propName, { includeDescriptions: context.includeDescriptions });
+      if (jsdoc) {
+        properties.push(`${jsdoc.trimEnd()}
+${propertyDef}`);
+      } else {
+        properties.push(propertyDef);
+      }
+    }
+  }
+  let objectMethod;
+  if (schema.additionalProperties === false) {
+    objectMethod = "z.strictObject";
+  } else {
+    switch (context.mode) {
+      case "strict":
+        objectMethod = "z.strictObject";
+        break;
+      case "loose":
+        objectMethod = "z.looseObject";
+        break;
+      default:
+        objectMethod = "z.object";
+    }
+  }
+  let objectDef = `${objectMethod}({
+${properties.join(",\n")}
+})`;
+  if (schema.additionalProperties !== void 0) {
+    if (typeof schema.additionalProperties === "object") {
+      const additionalSchema = context.generatePropertySchema(schema.additionalProperties, currentSchema);
+      objectDef += `.catchall(${additionalSchema})`;
+    } else if (schema.additionalProperties === true) {
+      objectDef += ".catchall(z.unknown())";
+    }
+  } else if (schema.patternProperties) {
+    objectDef += ".catchall(z.unknown())";
+  }
+  if (schema.minProperties !== void 0 || schema.maxProperties !== void 0) {
+    const conditions = [];
+    if (schema.minProperties !== void 0) {
+      conditions.push(`Object.keys(obj).length >= ${schema.minProperties}`);
+    }
+    if (schema.maxProperties !== void 0) {
+      conditions.push(`Object.keys(obj).length <= ${schema.maxProperties}`);
+    }
+    const condition = conditions.join(" && ");
+    let message = "Object ";
+    if (schema.minProperties !== void 0 && schema.maxProperties !== void 0) {
+      message += `must have between ${schema.minProperties} and ${schema.maxProperties} properties`;
+    } else if (schema.minProperties !== void 0) {
+      message += `must have at least ${schema.minProperties} ${schema.minProperties === 1 ? "property" : "properties"}`;
+    } else {
+      message += `must have at most ${schema.maxProperties} ${schema.maxProperties === 1 ? "property" : "properties"}`;
+    }
+    objectDef += `.refine((obj) => ${condition}, { message: "${message}" })`;
+  }
+  const definedProps = new Set(Object.keys(schema.properties || {}));
+  const undefinedRequired = (schema.required || []).filter((prop) => !definedProps.has(prop));
+  if (undefinedRequired.length > 0) {
+    if (!objectDef.includes(".catchall(")) {
+      objectDef += ".catchall(z.unknown())";
+    }
+    const requiredChecks = undefinedRequired.map((prop) => `${generatePropertyAccess2(prop)} !== undefined`).join(" && ");
+    const propList = undefinedRequired.join(", ");
+    objectDef += `.refine((obj) => ${requiredChecks}, { message: "Missing required fields: ${propList}" })`;
+  }
+  if (schema.patternProperties) {
+    const definedProps2 = Object.keys(schema.properties || {});
+    const definedPropsSet = `new Set(${JSON.stringify(definedProps2)})`;
+    const patterns = Object.entries(schema.patternProperties);
+    const patternSchemas = patterns.map(([pattern, patternSchema]) => ({
+      pattern,
+      escapedPattern: pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'"),
+      zodSchema: context.generatePropertySchema(patternSchema, currentSchema)
+    }));
+    objectDef += `.superRefine((obj, ctx) => {
+			const definedPropsSet = ${definedPropsSet};
+			const patterns = ${JSON.stringify(patternSchemas.map((p) => ({ pattern: p.escapedPattern })))};
+			const schemas = [${patternSchemas.map((p) => p.zodSchema).join(", ")}];
+			const regexps = patterns.map(p => new RegExp(p.pattern));
+
+			// Check all object keys
+			for (const key of Object.keys(obj)) {
+				// Skip properties that are explicitly defined
+				if (definedPropsSet.has(key)) continue;
+
+				// Find first matching pattern (first-match-wins priority)
+				for (let i = 0; i < regexps.length; i++) {
+					if (regexps[i].test(key)) {
+						const validation = schemas[i].safeParse(obj[key]);
+						if (!validation.success) {
+							// Add detailed error messages with property name and pattern
+							for (const issue of validation.error.issues) {
+								ctx.addIssue({
+									...issue,
+									path: [key, ...issue.path],
+									message: \`Property '\${key}' (pattern '\${patterns[i].pattern}'): \${issue.message}\`
+								});
+							}
+						}
+						break; // First match wins, stop checking other patterns
+					}
+				}
+			}
+		})`;
+  }
+  if (schema.propertyNames) {
+    const hasPattern = schema.propertyNames.pattern !== void 0;
+    const hasMinLength = schema.propertyNames.minLength !== void 0;
+    const hasMaxLength = schema.propertyNames.maxLength !== void 0;
+    if (hasPattern || hasMinLength || hasMaxLength) {
+      const escapedPattern = hasPattern && schema.propertyNames.pattern ? schema.propertyNames.pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'") : null;
+      const minLen = schema.propertyNames.minLength;
+      const maxLen = schema.propertyNames.maxLength;
+      objectDef += `.superRefine((obj, ctx) => {
+				${escapedPattern ? `const pattern = /${escapedPattern}/;` : ""}
+
+				for (const key of Object.keys(obj)) {
+					const failures: string[] = [];
+
+					${hasPattern ? `
+					if (!pattern.test(key)) {
+						failures.push("must match pattern '${schema.propertyNames.pattern}'");
+					}
+					` : ""}
+
+					${hasMinLength ? `
+					if (key.length < ${minLen}) {
+						failures.push("must be at least ${minLen} characters");
+					}
+					` : ""}
+
+					${hasMaxLength ? `
+					if (key.length > ${maxLen}) {
+						failures.push("must be at most ${maxLen} characters");
+					}
+					` : ""}
+
+					if (failures.length > 0) {
+						ctx.addIssue({
+							code: "custom",
+							message: \`Property name '\${key}' \${failures.join(", ")}\`,
+							path: [key]
+						});
+					}
+				}
+			})`;
+    }
+  }
+  objectDef += generateDependencies(schema, context.generatePropertySchema, currentSchema);
+  objectDef += generateDependentRequired(schema);
+  objectDef += generateIfThenElse(schema);
+  return objectDef;
+}
+
+// src/validators/string-validator.ts
+var DEFAULT_FORMAT_MAP = {
+  uuid: "z.uuid()",
+  email: "z.email()",
+  uri: "z.url()",
+  url: "z.url()",
+  "uri-reference": 'z.string().refine((val) => !/\\s/.test(val), { message: "Must be a valid URI reference" })',
+  hostname: 'z.string().refine((val) => /^(?=.{1,253}$)(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\\.)*(?!-)[A-Za-z0-9-]{1,63}(?<!-)$/.test(val), { message: "Must be a valid hostname" })',
+  byte: "z.base64()",
+  binary: "z.string()",
+  date: "z.iso.date()",
+  time: "z.iso.time()",
+  duration: 'z.string().refine((val) => /^P(?:(?:\\d+Y)?(?:\\d+M)?(?:\\d+D)?(?:T(?:\\d+H)?(?:\\d+M)?(?:\\d+(?:\\.\\d+)?S)?)?|\\d+W)$/.test(val) && !/^PT?$/.test(val), { message: "Must be a valid ISO 8601 duration" })',
+  ipv4: "z.ipv4()",
+  ipv6: "z.ipv6()",
+  emoji: "z.emoji()",
+  base64: "z.base64()",
+  base64url: "z.base64url()",
+  nanoid: "z.nanoid()",
+  cuid: "z.cuid()",
+  cuid2: "z.cuid2()",
+  ulid: "z.ulid()",
+  cidr: "z.cidrv4()",
+  // Default to v4
+  cidrv4: "z.cidrv4()",
+  cidrv6: "z.cidrv6()",
+  "json-pointer": 'z.string().refine((val) => val === "" || /^(\\/([^~/]|~0|~1)+)+$/.test(val), { message: "Must be a valid JSON Pointer (RFC 6901)" })',
+  "relative-json-pointer": 'z.string().refine((val) => /^(0|[1-9]\\d*)(#|(\\/([^~/]|~0|~1)+)*)$/.test(val), { message: "Must be a valid relative JSON Pointer" })'
+};
+function buildDateTimeValidation(pattern) {
+  if (!pattern) {
+    return "z.iso.datetime()";
+  }
+  const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
+  if (patternStr === "") {
+    return "z.iso.datetime()";
+  }
+  try {
+    new RegExp(patternStr);
+  } catch (error) {
+    throw new Error(
+      `Invalid regular expression pattern for customDateTimeFormatRegex: ${patternStr}. ${error instanceof Error ? error.message : "Pattern is malformed"}`
+    );
+  }
+  const escapedPattern = escapePattern(patternStr);
+  return `z.string().regex(/${escapedPattern}/)`;
+}
+function generateStringValidation(schema, useDescribe, context) {
+  let validation;
+  const format = schema.format || "";
+  if (format === "date-time") {
+    validation = context.dateTimeValidation;
+  } else {
+    validation = DEFAULT_FORMAT_MAP[format] || "z.string()";
+  }
+  if (schema.minLength !== void 0) {
+    validation += `.min(${schema.minLength})`;
+  }
+  if (schema.maxLength !== void 0) {
+    validation += `.max(${schema.maxLength})`;
+  }
+  if (schema.pattern) {
+    let escapedPattern = context.patternCache.get(schema.pattern);
+    if (escapedPattern === void 0) {
+      escapedPattern = escapePattern(schema.pattern);
+      context.patternCache.set(schema.pattern, escapedPattern);
+    }
+    validation += `.regex(/${escapedPattern}/)`;
+  }
+  if (schema.contentEncoding && !schema.format) {
+    switch (schema.contentEncoding) {
+      case "base64":
+        validation = "z.base64()";
+        break;
+      case "base64url":
+        validation = "z.base64url()";
+        break;
+      case "quoted-printable":
+        validation = 'z.string().refine((val) => /^[\\x20-\\x7E\\r\\n=]*$/.test(val), { message: "Must be valid quoted-printable encoding" })';
+        break;
+      case "7bit":
+      case "8bit":
+      case "binary":
+        validation = "z.string()";
+        break;
+      default:
+        validation = `z.string().describe("Content encoding: ${schema.contentEncoding}")`;
+    }
+    if (schema.minLength !== void 0) {
+      validation += `.min(${schema.minLength})`;
+    }
+    if (schema.maxLength !== void 0) {
+      validation += `.max(${schema.maxLength})`;
+    }
+    if (schema.pattern) {
+      let escapedPattern = context.patternCache.get(schema.pattern);
+      if (escapedPattern === void 0) {
+        escapedPattern = escapePattern(schema.pattern);
+        context.patternCache.set(schema.pattern, escapedPattern);
+      }
+      validation += `.regex(/${escapedPattern}/)`;
+    }
+  } else if (schema.contentMediaType) {
+    const mediaType = schema.contentMediaType;
+    if (mediaType === "application/json") {
+      validation += `.refine((val) => { try { JSON.parse(val); return true; } catch { return false; } }, { message: "Must be valid JSON" })`;
+    } else if (mediaType === "application/xml" || mediaType === "text/xml") {
+      validation += `.refine((val) => { try { if (typeof DOMParser !== "undefined") { const parser = new DOMParser(); const doc = parser.parseFromString(val, "text/xml"); return !doc.querySelector("parsererror"); } return /^\\s*<[^>]+>/.test(val); } catch { return false; } }, { message: "Must be valid XML" })`;
+    } else if (mediaType === "application/yaml" || mediaType === "application/x-yaml" || mediaType === "text/yaml") {
+      validation += `.refine((val) => { try { return val.trim().length > 0 && !/^[[{]/.test(val.trim()); } catch { return false; } }, { message: "Must be valid YAML" })`;
+    } else if (mediaType === "text/html") {
+      validation += `.refine((val) => /<[^>]+>/.test(val), { message: "Must contain HTML tags" })`;
+    } else if (mediaType === "text/plain") {
+      validation += `.refine(() => true, { message: "Plain text content" })`;
+    }
+  }
+  return addDescription(validation, schema.description, useDescribe);
+}
+
+// src/generators/property-generator.ts
+var _PropertyGenerator = class _PropertyGenerator {
+  constructor(context) {
+    // Performance optimization: Memoize filtered property results
+    this.filteredPropsCache = /* @__PURE__ */ new Map();
+    // Performance optimization: LRU cache for generated schemas
+    this.schemaCache = new LRUCache(500);
+    this.context = context;
+  }
+  /**
+   * Check if a property should be included based on schemaType and readOnly/writeOnly flags
+   */
+  shouldIncludeProperty(schema) {
+    const rule = _PropertyGenerator.INCLUSION_RULES[this.context.schemaType];
+    return rule(schema);
+  }
+  /**
+   * Recursively filter any schema type (helper for composition schemas)
+   */
+  filterSchemaRecursive(schema) {
+    if (schema.$ref) {
+      return schema;
+    }
+    if (schema.properties) {
+      return this.filterNestedProperties(schema);
+    }
+    if (schema.type === "array" && schema.items && typeof schema.items === "object" && schema.items.properties) {
+      return {
+        ...schema,
+        items: this.filterNestedProperties(schema.items)
+      };
+    }
+    return schema;
+  }
+  /**
+   * Recursively filter properties in nested objects based on readOnly/writeOnly
+   * Performance optimized with memoization
+   */
+  filterNestedProperties(schema) {
+    var _a, _b;
+    const propKeys = schema.properties ? Object.keys(schema.properties).sort().join(",") : "";
+    const cacheKey = `${this.context.schemaType}:${schema.type || "unknown"}:${propKeys}:${((_a = schema.required) == null ? void 0 : _a.join(",")) || ""}`;
+    const cached = this.filteredPropsCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    if (!schema.properties) {
+      return schema;
+    }
+    const filteredProperties = {};
+    const filteredRequired = [];
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      if (!this.shouldIncludeProperty(propSchema)) {
+        continue;
+      }
+      let filteredPropSchema = propSchema;
+      if (propSchema.type === "object" && propSchema.properties) {
+        filteredPropSchema = this.filterNestedProperties(propSchema);
+      } else if (propSchema.type === "array" && propSchema.items && typeof propSchema.items === "object" && propSchema.items.properties) {
+        filteredPropSchema = {
+          ...propSchema,
+          items: this.filterNestedProperties(propSchema.items)
+        };
+      } else if (propSchema.allOf || propSchema.oneOf || propSchema.anyOf) {
+        if (propSchema.allOf) {
+          filteredPropSchema = {
+            ...propSchema,
+            allOf: propSchema.allOf.map((s) => this.filterSchemaRecursive(s))
+          };
+        } else if (propSchema.oneOf) {
+          filteredPropSchema = {
+            ...propSchema,
+            oneOf: propSchema.oneOf.map((s) => this.filterSchemaRecursive(s))
+          };
+        } else if (propSchema.anyOf) {
+          filteredPropSchema = {
+            ...propSchema,
+            anyOf: propSchema.anyOf.map((s) => this.filterSchemaRecursive(s))
+          };
+        }
+      }
+      filteredProperties[propName] = filteredPropSchema;
+      if ((_b = schema.required) == null ? void 0 : _b.includes(propName)) {
+        filteredRequired.push(propName);
+      }
+    }
+    const result = {
+      ...schema,
+      properties: filteredProperties,
+      required: filteredRequired.length > 0 ? filteredRequired : void 0
+    };
+    this.filteredPropsCache.set(cacheKey, result);
+    return result;
+  }
+  /**
+   * Resolve discriminator mapping to actual schema references
+   */
+  resolveDiscriminatorMapping(mapping, schemas) {
+    const mappedSchemas = [];
+    for (const [_, schemaRef] of Object.entries(mapping)) {
+      const matchingSchema = schemas.find((s) => {
+        if (s.$ref) {
+          return s.$ref === schemaRef || s.$ref.endsWith(schemaRef);
+        }
+        return false;
+      });
+      if (matchingSchema) {
+        mappedSchemas.push(matchingSchema);
+      } else {
+        mappedSchemas.push({ $ref: schemaRef });
+      }
+    }
+    for (const schema of schemas) {
+      if (!mappedSchemas.includes(schema)) {
+        mappedSchemas.push(schema);
+      }
+    }
+    return mappedSchemas;
+  }
+  /**
+   * Resolve a $ref string to the actual schema
+   */
+  resolveSchemaRef(ref) {
+    var _a, _b;
+    const schemaName = ref.split("/").pop();
+    if (!schemaName) return void 0;
+    return (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[schemaName];
+  }
+  /**
+   * Resolve a schema name through any aliases to get the actual schema name
+   * If the schema is an alias (allOf with single $ref), return the target name
+   */
+  resolveSchemaAlias(schemaName) {
+    var _a, _b;
+    const schema = (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[schemaName];
+    if (!schema) return schemaName;
+    if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref && !schema.properties && !schema.oneOf && !schema.anyOf) {
+      const targetName = resolveRef(schema.allOf[0].$ref);
+      return this.resolveSchemaAlias(targetName);
+    }
+    return schemaName;
+  }
+  /**
+   * Check if this is a circular dependency through aliases
+   */
+  isCircularThroughAlias(fromSchema, toSchema) {
+    var _a, _b;
+    const toSchemaSpec = (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[toSchema];
+    if (!toSchemaSpec) return false;
+    if (toSchemaSpec.allOf && toSchemaSpec.allOf.length === 1 && toSchemaSpec.allOf[0].$ref) {
+      const aliasTarget = resolveRef(toSchemaSpec.allOf[0].$ref);
+      return aliasTarget === fromSchema;
+    }
+    return false;
+  }
+  /**
+   * Generate union for multiple types (OpenAPI 3.1)
+   */
+  generateMultiTypeUnion(schema, currentSchema) {
+    if (!Array.isArray(schema.type)) {
+      return "z.unknown()";
+    }
+    const nonNullTypes = schema.type.filter((t) => t !== "null");
+    const schemas = nonNullTypes.map((type) => {
+      const typeSchema = { ...schema, type };
+      return this.generatePropertySchema(typeSchema, currentSchema);
+    });
+    return `z.union([${schemas.join(", ")}])`;
+  }
+  /**
+   * Apply unevaluatedProperties validation to a schema
+   */
+  applyUnevaluatedProperties(baseSchema, schema) {
+    const evaluatedProps = /* @__PURE__ */ new Set();
+    if (schema.properties) {
+      for (const propName of Object.keys(schema.properties)) {
+        evaluatedProps.add(propName);
+      }
+    }
+    const collectPropsFromComposition = (schemas) => {
+      var _a, _b;
+      if (!schemas) return;
+      for (const subSchema of schemas) {
+        if (subSchema.properties) {
+          for (const propName of Object.keys(subSchema.properties)) {
+            evaluatedProps.add(propName);
+          }
+        }
+        if (subSchema.$ref) {
+          const refSchema = (_b = (_a = this.context.spec.components) == null ? void 0 : _a.schemas) == null ? void 0 : _b[subSchema.$ref.split("/").pop() || ""];
+          if (refSchema == null ? void 0 : refSchema.properties) {
+            for (const propName of Object.keys(refSchema.properties)) {
+              evaluatedProps.add(propName);
+            }
+          }
+        }
+      }
+    };
+    collectPropsFromComposition(schema.allOf);
+    collectPropsFromComposition(schema.oneOf);
+    collectPropsFromComposition(schema.anyOf);
+    const evaluatedPropsSet = `new Set(${JSON.stringify([...evaluatedProps])})`;
+    let schemaWithCatchall = baseSchema;
+    if (baseSchema.includes(".union([") || baseSchema.includes(".discriminatedUnion(")) {
+      schemaWithCatchall = baseSchema;
+    } else if (baseSchema.includes(".extend(")) {
+      schemaWithCatchall = `${baseSchema}.catchall(z.unknown())`;
+    }
+    if (schema.unevaluatedProperties === false) {
+      return `${schemaWithCatchall}.refine((obj) => Object.keys(obj).every(key => ${evaluatedPropsSet}.has(key)), { message: "No unevaluated properties allowed" })`;
+    } else if (typeof schema.unevaluatedProperties === "object") {
+      const unevalSchema = this.generatePropertySchema(schema.unevaluatedProperties);
+      return `${schemaWithCatchall}.refine((obj) => Object.keys(obj).filter(key => !${evaluatedPropsSet}.has(key)).every(key => ${unevalSchema}.safeParse(obj[key]).success), { message: "Unevaluated properties must match the schema" })`;
+    }
+    return baseSchema;
+  }
+  /**
+   * Generate Zod schema for a property
+   * @param schema - The OpenAPI schema to generate
+   * @param currentSchema - The name of the current schema being processed (for circular ref detection)
+   * @param isTopLevel - Whether this is a top-level schema definition
+   * @param suppressDefaultNullable - When true, don't apply defaultNullable (used when outer schema has explicit nullable: false)
+   */
+  generatePropertySchema(schema, currentSchema, isTopLevel = false, suppressDefaultNullable = false) {
+    var _a, _b, _c, _d, _e;
+    const isCacheable = !schema.$ref && !schema.allOf && !schema.oneOf && !schema.anyOf && !currentSchema;
+    if (isCacheable) {
+      const cacheKey = JSON.stringify({
+        schema,
+        type: this.context.schemaType,
+        mode: this.context.mode,
+        suppressDefaultNullable
+      });
+      const cached = this.schemaCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    if ((this.context.schemaType === "request" || this.context.schemaType === "response") && schema.properties) {
+      schema = this.filterNestedProperties(schema);
+    }
+    const isEnum = !!schema.enum;
+    const isConst = schema.const !== void 0;
+    const shouldApplyDefaultNullable = !isTopLevel && !isEnum && !isConst && !suppressDefaultNullable;
+    const effectiveDefaultNullable = shouldApplyDefaultNullable ? this.context.defaultNullable : false;
+    const nullable = isNullable(schema, effectiveDefaultNullable);
+    if (hasMultipleTypes(schema)) {
+      const union = this.generateMultiTypeUnion(schema, currentSchema);
+      return wrapNullable(union, nullable);
+    }
+    if (schema.$ref) {
+      const refName = resolveRef(schema.$ref);
+      const resolvedRefName = this.resolveSchemaAlias(refName);
+      if (currentSchema && refName !== currentSchema && !isTopLevel) {
+        if (!this.context.schemaDependencies.has(currentSchema)) {
+          this.context.schemaDependencies.set(currentSchema, /* @__PURE__ */ new Set());
+        }
+        (_a = this.context.schemaDependencies.get(currentSchema)) == null ? void 0 : _a.add(refName);
+      }
+      const strippedRefName = stripPrefix(resolvedRefName, this.context.stripSchemaPrefix);
+      const schemaName = `${toCamelCase(strippedRefName, this.context.namingOptions)}Schema`;
+      if (currentSchema && (refName === currentSchema || this.isCircularThroughAlias(currentSchema, refName))) {
+        const lazySchema = `z.lazy((): z.ZodTypeAny => ${schemaName})`;
+        return wrapNullable(lazySchema, nullable);
+      }
+      return wrapNullable(schemaName, nullable);
+    }
+    if (schema.const !== void 0) {
+      const literalValue = typeof schema.const === "string" ? `"${schema.const}"` : schema.const;
+      const zodLiteral = `z.literal(${literalValue})`;
+      return wrapNullable(zodLiteral, nullable);
+    }
+    if (schema.enum) {
+      const allBooleans = schema.enum.every((v) => typeof v === "boolean");
+      if (allBooleans) {
+        const zodBoolean = "z.boolean()";
+        return wrapNullable(zodBoolean, nullable);
+      }
+      const allStrings = schema.enum.every((v) => typeof v === "string");
+      if (allStrings) {
+        const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+        const zodEnum = `z.enum([${enumValues}])`;
+        return wrapNullable(zodEnum, nullable);
+      }
+      const literalValues = schema.enum.map((v) => {
+        if (typeof v === "string") {
+          return `z.literal("${v}")`;
+        }
+        return `z.literal(${v})`;
+      }).join(", ");
+      const zodUnion = `z.union([${literalValues}])`;
+      return wrapNullable(zodUnion, nullable);
+    }
+    if (schema.allOf) {
+      const compositionNullable = isNullable(schema, false);
+      let composition = generateAllOf(
+        schema.allOf,
+        compositionNullable,
+        {
+          generatePropertySchema: this.generatePropertySchema.bind(this),
+          generateInlineObjectShape: this.generateInlineObjectShape.bind(this),
+          resolveSchemaRef: this.resolveSchemaRef.bind(this)
+        },
+        currentSchema
+      );
+      if (schema.unevaluatedProperties !== void 0) {
+        composition = this.applyUnevaluatedProperties(composition, schema);
+      }
+      return composition;
+    }
+    if (schema.oneOf) {
+      const compositionNullable = isNullable(schema, false);
+      const needsPassthrough = schema.unevaluatedProperties !== void 0;
+      let composition = generateUnion(
+        schema.oneOf,
+        (_b = schema.discriminator) == null ? void 0 : _b.propertyName,
+        compositionNullable,
+        {
+          generatePropertySchema: this.generatePropertySchema.bind(this),
+          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
+          resolveSchemaRef: this.resolveSchemaRef.bind(this)
+        },
+        {
+          passthrough: needsPassthrough,
+          discriminatorMapping: (_c = schema.discriminator) == null ? void 0 : _c.mapping
+        },
+        currentSchema
+      );
+      if (schema.unevaluatedProperties !== void 0) {
+        composition = this.applyUnevaluatedProperties(composition, schema);
+      }
+      return composition;
+    }
+    if (schema.anyOf) {
+      const compositionNullable = isNullable(schema, false);
+      const needsPassthrough = schema.unevaluatedProperties !== void 0;
+      let composition = generateUnion(
+        schema.anyOf,
+        (_d = schema.discriminator) == null ? void 0 : _d.propertyName,
+        compositionNullable,
+        {
+          generatePropertySchema: this.generatePropertySchema.bind(this),
+          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
+          resolveSchemaRef: this.resolveSchemaRef.bind(this)
+        },
+        {
+          passthrough: needsPassthrough,
+          discriminatorMapping: (_e = schema.discriminator) == null ? void 0 : _e.mapping
+        },
+        currentSchema
+      );
+      if (schema.unevaluatedProperties !== void 0) {
+        composition = this.applyUnevaluatedProperties(composition, schema);
+      }
+      return composition;
+    }
+    if (schema.not) {
+      const notSchema = this.generatePropertySchema(schema.not, currentSchema);
+      let baseValidation;
+      if (schema.type || schema.properties || schema.items) {
+        const { not: _, ...baseSchema } = schema;
+        baseValidation = this.generatePropertySchema(baseSchema, currentSchema);
+      } else {
+        baseValidation = "z.unknown()";
+      }
+      const refined = `${baseValidation}.refine((val) => !${notSchema}.safeParse(val).success, { message: "Value must not match the excluded schema" })`;
+      return wrapNullable(refined, nullable);
+    }
+    let validation = "";
+    const primaryType = getPrimaryType(schema);
+    switch (primaryType) {
+      case "string":
+        validation = generateStringValidation(schema, this.context.useDescribe, {
+          dateTimeValidation: this.context.dateTimeValidation,
+          patternCache: this.context.patternCache
+        });
+        break;
+      case "number":
+        validation = generateNumberValidation(schema, false, this.context.useDescribe);
+        break;
+      case "integer":
+        validation = generateNumberValidation(schema, true, this.context.useDescribe);
+        break;
+      case "boolean":
+        validation = "z.boolean()";
+        validation = addDescription(validation, schema.description, this.context.useDescribe);
+        break;
+      case "array":
+        validation = generateArrayValidation(schema, {
+          generatePropertySchema: this.generatePropertySchema.bind(this),
+          useDescribe: this.context.useDescribe,
+          currentSchema
+        });
+        break;
+      case "object":
+        if (schema.properties || schema.required || schema.minProperties !== void 0 || schema.maxProperties !== void 0 || schema.patternProperties || schema.propertyNames) {
+          validation = generateObjectSchema(
+            schema,
+            {
+              generatePropertySchema: this.generatePropertySchema.bind(this),
+              shouldIncludeProperty: this.shouldIncludeProperty.bind(this),
+              mode: this.context.mode,
+              includeDescriptions: this.context.includeDescriptions,
+              useDescribe: this.context.useDescribe
+            },
+            currentSchema
+          );
+          validation = addDescription(validation, schema.description, this.context.useDescribe);
+        } else {
+          switch (this.context.emptyObjectBehavior) {
+            case "strict":
+              validation = "z.strictObject({})";
+              break;
+            case "loose":
+              validation = "z.looseObject({})";
+              break;
+            default:
+              validation = "z.record(z.string(), z.unknown())";
+              break;
+          }
+          validation = addDescription(validation, schema.description, this.context.useDescribe);
+        }
+        break;
+      default:
+        validation = "z.unknown()";
+        validation = addDescription(validation, schema.description, this.context.useDescribe);
+    }
+    const result = wrapNullable(validation, nullable);
+    if (isCacheable) {
+      const cacheKey = JSON.stringify({ schema, type: this.context.schemaType, mode: this.context.mode });
+      this.schemaCache.set(cacheKey, result);
+    }
+    return result;
+  }
+  /**
+   * Generate inline object shape for use with .extend()
+   * Returns just the shape object literal: { prop1: z.string(), prop2: z.number() }
+   *
+   * This method is specifically for allOf compositions where we need to pass
+   * the shape directly to .extend() instead of using z.object({...}).shape.
+   * This avoids the .nullable().shape bug when inline objects have nullable: true.
+   *
+   * According to Zod docs (https://zod.dev/api?id=extend):
+   * - .extend() accepts an object of shape definitions
+   * - e.g., baseSchema.extend({ prop: z.string() })
+   */
+  generateInlineObjectShape(schema, currentSchema) {
+    const required = new Set(schema.required || []);
+    const properties = [];
+    if (schema.properties) {
+      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        if (!this.shouldIncludeProperty(propSchema)) {
+          continue;
+        }
+        const isRequired = required.has(propName);
+        const zodSchema = this.generatePropertySchema(propSchema, currentSchema);
+        const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+        const quotedPropName = validIdentifier.test(propName) ? propName : `"${propName}"`;
+        let propertyDef = `${quotedPropName}: ${zodSchema}`;
+        if (!isRequired) {
+          propertyDef += ".optional()";
+        }
+        properties.push(propertyDef);
+      }
+    }
+    if (properties.length === 0) {
+      return "{}";
+    }
+    return `{
+${properties.map((p) => `	${p}`).join(",\n")}
+}`;
+  }
+};
+// Performance optimization: Lookup table for faster inclusion checks
+_PropertyGenerator.INCLUSION_RULES = {
+  request: (schema) => !schema.readOnly,
+  response: (schema) => !schema.writeOnly,
+  all: () => true
+};
+var PropertyGenerator = _PropertyGenerator;
+
 // src/utils/config-schemas.ts
 import { z } from "zod";
 var RequestResponseOptionsSchema = z.strictObject({
@@ -221,95 +1717,8 @@ function getResponseParseMethod(contentType, fallback = "text") {
   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";
+import { minimatch as minimatch2 } from "minimatch";
 function createFilterStatistics() {
   return {
     totalOperations: 0,
@@ -328,7 +1737,7 @@ function matchesAnyPattern(value, patterns) {
   if (!value) {
     return false;
   }
-  return patterns.some((pattern) => minimatch(value, pattern));
+  return patterns.some((pattern) => minimatch2(value, pattern));
 }
 function containsAny(arr, values) {
   if (!values || values.length === 0) {
@@ -442,82 +1851,8 @@ function formatFilterStatistics(stats) {
   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) {
+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;
@@ -542,20 +1877,20 @@ function resolveRef(obj, spec, maxDepth = 10) {
   }
   if (resolved) {
     if (resolved.$ref) {
-      return resolveRef(resolved, spec, maxDepth - 1);
+      return resolveRef2(resolved, spec, maxDepth - 1);
     }
     return resolved;
   }
   return obj;
 }
 function resolveParameterRef(param, spec) {
-  return resolveRef(param, spec);
+  return resolveRef2(param, spec);
 }
 function resolveRequestBodyRef(requestBody, spec) {
-  return resolveRef(requestBody, spec);
+  return resolveRef2(requestBody, spec);
 }
 function resolveResponseRef(response, spec) {
-  return resolveRef(response, spec);
+  return resolveRef2(response, spec);
 }
 function mergeParameters(pathParams, operationParams, spec) {
   const resolvedPathParams = (pathParams || []).map((p) => resolveParameterRef(p, spec));
@@ -575,14 +1910,6 @@ function mergeParameters(pathParams, operationParams, spec) {
   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) => {
@@ -616,72 +1943,12 @@ function createTypeScriptLoader() {
     }
   };
 }
-
-// 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,
+  PropertyGenerator,
   RequestResponseOptionsSchema,
-  configureDateTimeFormat,
+  buildDateTimeValidation,
   createFilterStatistics,
   createTypeScriptLoader,
   escapeJSDoc,
@@ -691,9 +1958,8 @@ export {
   getBatchExitCode,
   getResponseParseMethod,
   mergeParameters,
-  resetFormatMap,
   resolveParameterRef,
-  resolveRef,
+  resolveRef2 as resolveRef,
   resolveRequestBodyRef,
   resolveResponseRef,
   shouldIncludeOperation,