@cerios/openapi-to-zod 1.1.1 → 1.3.0

package/dist/cli.mjs

@@ -5241,14 +5241,17 @@ function escapeJSDoc(str) {
 function wrapNullable(validation, isNullable2) {
   return isNullable2 ? `${validation}.nullable()` : validation;
 }
-function isNullable(schema) {
+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 false;
+  return defaultNullable;
 }
 function getPrimaryType(schema) {
   if (Array.isArray(schema.type)) {
@@ -5434,6 +5437,22 @@ function stripPrefix(input, pattern, ensureLeadingChar) {
   }
   return input;
 }
+function stripPathPrefix(path2, pattern) {
+  if (!pattern) {
+    return path2;
+  }
+  if (!isGlobPattern(pattern)) {
+    let normalizedPattern = pattern.trim();
+    if (!normalizedPattern.startsWith("/")) {
+      normalizedPattern = `/${normalizedPattern}`;
+    }
+    if (normalizedPattern.endsWith("/") && normalizedPattern !== "/") {
+      normalizedPattern = normalizedPattern.slice(0, -1);
+    }
+    return stripPrefix(path2, normalizedPattern, "/");
+  }
+  return stripPrefix(path2, pattern, "/");
+}
 var init_pattern_utils = __esm({
   "src/utils/pattern-utils.ts"() {
     "use strict";
@@ -5495,12 +5514,56 @@ var init_array_validator = __esm({
 });
 
 // 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);
+    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));
+      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));
     if (options == null ? void 0 : options.passthrough) {
       schemaStrings2 = schemaStrings2.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
@@ -5515,25 +5578,102 @@ function generateUnion(schemas, discriminator, isNullable2, context, options, cu
   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);
     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);
-  const schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema, false));
+  let result;
   if (allObjects) {
-    let merged2 = schemaStrings[0];
+    let merged = context.generatePropertySchema(schemas[0], currentSchema, false);
+    for (let i = 1; i < schemas.length; i++) {
+      const schema = schemas[i];
+      if (schema.$ref) {
+        const refSchema = context.generatePropertySchema(schema, currentSchema, false);
+        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);
+        merged = `${merged}.extend(${schemaString}.shape)`;
+      }
+    }
+    result = merged;
+  } else {
+    const schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema, false));
+    let merged = schemaStrings[0];
     for (let i = 1; i < schemaStrings.length; i++) {
-      merged2 = `${merged2}.merge(${schemaStrings[i]})`;
+      merged = `${merged}.and(${schemaStrings[i]})`;
     }
-    return wrapNullable(merged2, isNullable2);
+    result = merged;
   }
-  let merged = schemaStrings[0];
-  for (let i = 1; i < schemaStrings.length; i++) {
-    merged = `${merged}.and(${schemaStrings[i]})`;
+  if (conflictDescription) {
+    result = `${result}.describe("${conflictDescription}")`;
   }
-  return wrapNullable(merged, isNullable2);
+  return wrapNullable(result, isNullable2);
 }
 var init_composition_validator = __esm({
   "src/validators/composition-validator.ts"() {
@@ -5999,6 +6139,26 @@ function configurePatternCache(size) {
     PATTERN_CACHE = new LRUCache(size);
   }
 }
+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 generateStringValidation(schema, useDescribe) {
   let validation = FORMAT_MAP[schema.format || ""] || "z.string()";
   if (schema.minLength !== void 0) {
@@ -6064,7 +6224,7 @@ function generateStringValidation(schema, useDescribe) {
   }
   return addDescription(validation, schema.description, useDescribe);
 }
-var PATTERN_CACHE, FORMAT_MAP;
+var PATTERN_CACHE, DEFAULT_FORMAT_MAP, FORMAT_MAP;
 var init_string_validator = __esm({
   "src/validators/string-validator.ts"() {
     "use strict";
@@ -6072,7 +6232,7 @@ var init_string_validator = __esm({
     init_lru_cache();
     init_string_utils();
     PATTERN_CACHE = new LRUCache(1e3);
-    FORMAT_MAP = {
+    DEFAULT_FORMAT_MAP = {
       uuid: "z.uuid()",
       email: "z.email()",
       uri: "z.url()",
@@ -6082,7 +6242,6 @@ var init_string_validator = __esm({
       byte: "z.base64()",
       binary: "z.string()",
       date: "z.iso.date()",
-      "date-time": "z.iso.datetime()",
       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()",
@@ -6101,6 +6260,10 @@ var init_string_validator = __esm({
       "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" })'
     };
+    FORMAT_MAP = {
+      ...DEFAULT_FORMAT_MAP,
+      "date-time": "z.iso.datetime()"
+    };
   }
 });
 
@@ -6237,6 +6400,15 @@ var init_property_generator = __esm({
         }
         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
@@ -6314,7 +6486,7 @@ var init_property_generator = __esm({
         let schemaWithCatchall = baseSchema;
         if (baseSchema.includes(".union([") || baseSchema.includes(".discriminatedUnion(")) {
           schemaWithCatchall = baseSchema;
-        } else if (baseSchema.includes(".merge(")) {
+        } else if (baseSchema.includes(".extend(")) {
           schemaWithCatchall = `${baseSchema}.catchall(z.unknown())`;
         }
         if (schema.unevaluatedProperties === false) {
@@ -6341,7 +6513,12 @@ var init_property_generator = __esm({
         if ((this.context.schemaType === "request" || this.context.schemaType === "response") && schema.properties) {
           schema = this.filterNestedProperties(schema);
         }
-        const nullable = isNullable(schema);
+        const isSchemaRef = !!schema.$ref;
+        const isEnum = !!schema.enum;
+        const isConst = schema.const !== void 0;
+        const shouldApplyDefaultNullable = !isTopLevel && !isSchemaRef && !isEnum && !isConst;
+        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);
@@ -6393,7 +6570,11 @@ var init_property_generator = __esm({
           let composition = generateAllOf(
             schema.allOf,
             nullable,
-            { generatePropertySchema: this.generatePropertySchema.bind(this) },
+            {
+              generatePropertySchema: this.generatePropertySchema.bind(this),
+              generateInlineObjectShape: this.generateInlineObjectShape.bind(this),
+              resolveSchemaRef: this.resolveSchemaRef.bind(this)
+            },
             currentSchema
           );
           if (schema.unevaluatedProperties !== void 0) {
@@ -6409,7 +6590,8 @@ var init_property_generator = __esm({
             nullable,
             {
               generatePropertySchema: this.generatePropertySchema.bind(this),
-              resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this)
+              resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
+              resolveSchemaRef: this.resolveSchemaRef.bind(this)
             },
             {
               passthrough: needsPassthrough,
@@ -6430,7 +6612,8 @@ var init_property_generator = __esm({
             nullable,
             {
               generatePropertySchema: this.generatePropertySchema.bind(this),
-              resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this)
+              resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
+              resolveSchemaRef: this.resolveSchemaRef.bind(this)
             },
             {
               passthrough: needsPassthrough,
@@ -6493,7 +6676,17 @@ var init_property_generator = __esm({
               );
               validation = addDescription(validation, schema.description, this.context.useDescribe);
             } else {
-              validation = "z.record(z.string(), z.unknown())";
+              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;
@@ -6508,6 +6701,44 @@ var init_property_generator = __esm({
         }
         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 = {
@@ -6659,6 +6890,65 @@ var init_operation_filters = __esm({
   }
 });
 
+// src/utils/ref-resolver.ts
+function resolveRef2(obj, spec, maxDepth = 10) {
+  var _a, _b, _c, _d;
+  if (!obj || typeof obj !== "object" || maxDepth <= 0) return obj;
+  if (!obj.$ref) return obj;
+  const ref = obj.$ref;
+  let resolved = null;
+  const paramMatch = ref.match(/^#\/components\/parameters\/(.+)$/);
+  const requestBodyMatch = ref.match(/^#\/components\/requestBodies\/(.+)$/);
+  const responseMatch = ref.match(/^#\/components\/responses\/(.+)$/);
+  const schemaMatch = ref.match(/^#\/components\/schemas\/(.+)$/);
+  if (paramMatch && ((_a = spec.components) == null ? void 0 : _a.parameters)) {
+    const name = paramMatch[1];
+    resolved = spec.components.parameters[name];
+  } else if (requestBodyMatch && ((_b = spec.components) == null ? void 0 : _b.requestBodies)) {
+    const name = requestBodyMatch[1];
+    resolved = spec.components.requestBodies[name];
+  } else if (responseMatch && ((_c = spec.components) == null ? void 0 : _c.responses)) {
+    const name = responseMatch[1];
+    resolved = spec.components.responses[name];
+  } else if (schemaMatch && ((_d = spec.components) == null ? void 0 : _d.schemas)) {
+    const name = schemaMatch[1];
+    resolved = spec.components.schemas[name];
+  }
+  if (resolved) {
+    if (resolved.$ref) {
+      return resolveRef2(resolved, spec, maxDepth - 1);
+    }
+    return resolved;
+  }
+  return obj;
+}
+function resolveParameterRef(param, spec) {
+  return resolveRef2(param, spec);
+}
+function 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;
+}
+var init_ref_resolver = __esm({
+  "src/utils/ref-resolver.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/openapi-generator.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, normalize } from "path";
@@ -6676,6 +6966,7 @@ var init_openapi_generator = __esm({
     init_name_utils();
     init_operation_filters();
     init_pattern_utils();
+    init_ref_resolver();
     init_string_validator();
     OpenApiGenerator = class {
       constructor(options) {
@@ -6685,7 +6976,7 @@ var init_openapi_generator = __esm({
         this.schemaUsageMap = /* @__PURE__ */ new Map();
         this.needsZodImport = true;
         this.filterStats = createFilterStatistics();
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _i;
         if (!options.input) {
           throw new ConfigurationError("Input path is required", { providedOptions: options });
         }
@@ -6695,21 +6986,28 @@ var init_openapi_generator = __esm({
           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",
           schemaType: options.schemaType || "all",
           prefix: options.prefix,
           suffix: options.suffix,
           stripSchemaPrefix: options.stripSchemaPrefix,
-          showStats: (_c = options.showStats) != null ? _c : true,
+          stripPathPrefix: options.stripPathPrefix,
+          showStats: (_e = options.showStats) != null ? _e : true,
           request: options.request,
           response: options.response,
           operationFilters: options.operationFilters,
           ignoreHeaders: options.ignoreHeaders,
-          cacheSize: (_d = options.cacheSize) != null ? _d : 1e3,
-          batchSize: (_e = options.batchSize) != null ? _e : 10
+          cacheSize: (_f = options.cacheSize) != null ? _f : 1e3,
+          batchSize: (_g = options.batchSize) != null ? _g : 10,
+          customDateTimeFormatRegex: options.customDateTimeFormatRegex
         };
         if (this.options.cacheSize) {
           configurePatternCache(this.options.cacheSize);
         }
+        if (this.options.customDateTimeFormatRegex) {
+          configureDateTimeFormat(this.options.customDateTimeFormatRegex);
+        }
         try {
           const fs = __require("fs");
           if (!fs.existsSync(this.options.input)) {
@@ -6772,6 +7070,8 @@ var init_openapi_generator = __esm({
           mode: this.requestOptions.mode,
           includeDescriptions: this.requestOptions.includeDescriptions,
           useDescribe: this.requestOptions.useDescribe,
+          defaultNullable: (_h = this.options.defaultNullable) != null ? _h : false,
+          emptyObjectBehavior: (_i = this.options.emptyObjectBehavior) != null ? _i : "loose",
           namingOptions: {
             prefix: this.options.prefix,
             suffix: this.options.suffix
@@ -7125,7 +7425,7 @@ var init_openapi_generator = __esm({
        * Generate schema for a component
        */
       generateComponentSchema(name, schema) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (!this.schemaDependencies.has(name)) {
           this.schemaDependencies.set(name, /* @__PURE__ */ new Set());
         }
@@ -7157,14 +7457,15 @@ ${typeCode}`;
           mode: resolvedOptions.mode,
           includeDescriptions: resolvedOptions.includeDescriptions,
           useDescribe: resolvedOptions.useDescribe,
+          defaultNullable: (_b = this.options.defaultNullable) != null ? _b : false,
+          emptyObjectBehavior: (_c = this.options.emptyObjectBehavior) != null ? _c : "loose",
           namingOptions: {
             prefix: this.options.prefix,
             suffix: this.options.suffix
           },
           stripSchemaPrefix: this.options.stripSchemaPrefix
         });
-        const isAlias = !!(schema.$ref && !schema.properties && !schema.allOf && !schema.oneOf && !schema.anyOf);
-        const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, isAlias);
+        const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, true);
         const zodSchemaCode = `${jsdoc}export const ${schemaName} = ${zodSchema};`;
         if (zodSchema.includes("z.discriminatedUnion(")) {
           const match = zodSchema.match(/z\.discriminatedUnion\([^,]+,\s*\[([^\]]+)\]/);
@@ -7174,7 +7475,7 @@ ${typeCode}`;
               const depMatch = ref.match(/^([a-z][a-zA-Z0-9]*?)Schema$/);
               if (depMatch) {
                 const depName = depMatch[1].charAt(0).toUpperCase() + depMatch[1].slice(1);
-                (_b = this.schemaDependencies.get(name)) == null ? void 0 : _b.add(depName);
+                (_d = this.schemaDependencies.get(name)) == null ? void 0 : _d.add(depName);
               }
             }
           }
@@ -7198,16 +7499,20 @@ ${typeCode}`;
             if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters)) {
               continue;
             }
-            if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
-              continue;
-            }
-            const queryParams = operation.parameters.filter(
+            const allParams = mergeParameters(pathItem.parameters, operation.parameters, this.spec);
+            const queryParams = allParams.filter(
               (param) => param && typeof param === "object" && param.in === "query"
             );
             if (queryParams.length === 0) {
               continue;
             }
-            const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            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(path2, this.options.stripPathPrefix);
+              pascalOperationId = this.generateMethodNameFromPath(method, strippedPath);
+            }
             const schemaName = `${pascalOperationId}QueryParams`;
             if (!this.schemaDependencies.has(schemaName)) {
               this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
@@ -7255,8 +7560,9 @@ ${propsCode}
             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 jsdocOperationName = operation.operationId || `${method.toUpperCase()} ${path2}`;
             const jsdoc = `/**
- * Query parameters for ${operation.operationId}
+ * Query parameters for ${jsdocOperationName}
  */
 `;
             const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
@@ -7265,6 +7571,35 @@ ${propsCode}
           }
         }
       }
+      /**
+       * Generate a PascalCase method name from HTTP method and path
+       * Used as fallback when operationId is not available
+       * @internal
+       */
+      generateMethodNameFromPath(method, path2) {
+        const segments = path2.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
@@ -7301,16 +7636,20 @@ ${propsCode}
             if (!shouldIncludeOperation(operation, path2, method, this.options.operationFilters)) {
               continue;
             }
-            if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
-              continue;
-            }
-            const headerParams = operation.parameters.filter(
+            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)
             );
             if (headerParams.length === 0) {
               continue;
             }
-            const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+            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(path2, this.options.stripPathPrefix);
+              pascalOperationId = this.generateMethodNameFromPath(method, strippedPath);
+            }
             const schemaName = `${pascalOperationId}HeaderParams`;
             if (!this.schemaDependencies.has(schemaName)) {
               this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
@@ -7347,8 +7686,9 @@ ${propsCode}
             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 jsdocOperationName = operation.operationId || `${method.toUpperCase()} ${path2}`;
             const jsdoc = `/**
- * Header parameters for ${operation.operationId}
+ * Header parameters for ${jsdocOperationName}
  */
 `;
             const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
@@ -7387,13 +7727,23 @@ ${propsCode}
         }
         const type = schema.type;
         if (type === "string") {
+          const formatMap = {
+            email: "z.email()",
+            uri: "z.url()",
+            url: "z.url()",
+            uuid: "z.uuid()"
+          };
+          if (schema.format && formatMap[schema.format]) {
+            let zodType2 = formatMap[schema.format];
+            if (schema.minLength !== void 0) zodType2 = `${zodType2}.min(${schema.minLength})`;
+            if (schema.maxLength !== void 0) zodType2 = `${zodType2}.max(${schema.maxLength})`;
+            if (schema.pattern) zodType2 = `${zodType2}.regex(/${schema.pattern}/)`;
+            return zodType2;
+          }
           let zodType = "z.string()";
           if (schema.minLength !== void 0) zodType = `${zodType}.min(${schema.minLength})`;
           if (schema.maxLength !== void 0) zodType = `${zodType}.max(${schema.maxLength})`;
           if (schema.pattern) zodType = `${zodType}.regex(/${schema.pattern}/)`;
-          if (schema.format === "email") zodType = `${zodType}.email()`;
-          if (schema.format === "uri" || schema.format === "url") zodType = `${zodType}.url()`;
-          if (schema.format === "uuid") zodType = `${zodType}.uuid()`;
           return zodType;
         }
         if (type === "number" || type === "integer") {
@@ -7418,11 +7768,6 @@ ${propsCode}
         }
         return "z.unknown()";
       }
-      // REMOVED: generateNativeEnum method - no longer needed as we only generate Zod schemas
-      // REMOVED: toEnumKey method - was only used by generateNativeEnum
-      // REMOVED: addConstraintsToJSDoc method - was only used for native TypeScript types
-      // REMOVED: generateNativeTypeDefinition method - was only used for native TypeScript types
-      // REMOVED: generateObjectType method - was only used for native TypeScript types
       /**
        * Topological sort for schema dependencies
        * Returns schemas in the order they should be declared
@@ -7529,7 +7874,8 @@ var init_config_schemas = __esm({
     RequestResponseOptionsSchema = z.strictObject({
       mode: z.enum(["strict", "normal", "loose"]).optional(),
       useDescribe: z.boolean().optional(),
-      includeDescriptions: z.boolean().optional()
+      includeDescriptions: z.boolean().optional(),
+      defaultNullable: z.boolean().optional()
     });
     OperationFiltersSchema = z.strictObject({
       includeTags: z.array(z.string()).optional(),
@@ -7660,10 +8006,12 @@ function mergeConfigWithDefaults(config) {
       mode: defaults.mode,
       includeDescriptions: defaults.includeDescriptions,
       useDescribe: defaults.useDescribe,
+      defaultNullable: defaults.defaultNullable,
       schemaType: defaults.schemaType,
       prefix: defaults.prefix,
       suffix: defaults.suffix,
       showStats: defaults.showStats,
+      customDateTimeFormatRegex: defaults.customDateTimeFormatRegex,
       // Override with spec-specific values (including required input/output)
       ...spec
     };
@@ -7684,6 +8032,7 @@ var init_config_loader = __esm({
       output: z2.string(),
       includeDescriptions: z2.boolean().optional(),
       useDescribe: z2.boolean().optional(),
+      defaultNullable: z2.boolean().optional(),
       schemaType: z2.enum(["all", "request", "response"]).optional(),
       prefix: z2.string().optional(),
       suffix: z2.string().optional(),
@@ -7694,13 +8043,28 @@ var init_config_loader = __esm({
       name: z2.string().optional(),
       operationFilters: OperationFiltersSchema.optional(),
       cacheSize: z2.number().positive().optional(),
-      batchSize: z2.number().positive().optional()
+      batchSize: z2.number().positive().optional(),
+      customDateTimeFormatRegex: z2.union([
+        z2.string().refine(
+          (pattern) => {
+            try {
+              new RegExp(pattern);
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          { message: "Must be a valid regular expression pattern" }
+        ),
+        z2.instanceof(RegExp)
+      ]).optional()
     });
     ConfigFileSchema = z2.strictObject({
       defaults: z2.strictObject({
         mode: z2.enum(["strict", "normal", "loose"]).optional(),
         includeDescriptions: z2.boolean().optional(),
         useDescribe: z2.boolean().optional(),
+        defaultNullable: z2.boolean().optional(),
         schemaType: z2.enum(["all", "request", "response"]).optional(),
         prefix: z2.string().optional(),
         suffix: z2.string().optional(),
@@ -7710,7 +8074,21 @@ var init_config_loader = __esm({
         response: RequestResponseOptionsSchema.optional(),
         operationFilters: OperationFiltersSchema.optional(),
         cacheSize: z2.number().positive().optional(),
-        batchSize: z2.number().positive().optional()
+        batchSize: z2.number().positive().optional(),
+        customDateTimeFormatRegex: z2.union([
+          z2.string().refine(
+            (pattern) => {
+              try {
+                new RegExp(pattern);
+                return true;
+              } catch {
+                return false;
+              }
+            },
+            { message: "Must be a valid regular expression pattern" }
+          ),
+          z2.instanceof(RegExp)
+        ]).optional()
       }).optional(),
       specs: z2.array(OpenApiGeneratorOptionsSchema).min(1, {
         message: "Configuration must include at least one specification. Each specification should have 'input' and 'output' paths."