@cerios/openapi-to-zod 1.2.0 → 1.3.0

package/README.md

@@ -19,7 +19,7 @@ Transform OpenAPI YAML specifications into Zod v4 compliant schemas with full Ty
 - 📊 **Statistics**: Optional generation statistics in output files
 - ❗ **Better Errors**: Clear error messages with file paths and line numbers
 - 🎭 **Tuple Validation**: OpenAPI 3.1 `prefixItems` support with `.tuple()` and `.rest()`
-- 🔗 **Smart AllOf**: Uses `.merge()` for objects, `.and()` for primitives
+- 🔗 **Smart AllOf**: Uses `.extend()` for objects (Zod v4), `.and()` for primitives
 - 🎯 **Literal Types**: `const` keyword support with `z.literal()`
 - 🔢 **Exclusive Bounds**: `exclusiveMinimum`/`exclusiveMaximum` with `.gt()`/`.lt()`
 - 🎨 **Unique Arrays**: `uniqueItems` validation with Set-based checking
@@ -181,7 +181,8 @@ Examples:
 | `name` | `string` | Optional identifier for logging |
 | `input` | `string` | Input OpenAPI YAML file path (required) |
 | `output` | `string` | Output TypeScript file path (required) |
-| `mode` | `"strict"` \| `"normal"` \| `"loose"` | Validation mode |
+| `mode` | `"strict"` \| `"normal"` \| `"loose"` | Validation mode for top-level schemas (default: `"normal"`) |
+| `emptyObjectBehavior` | `"strict"` \| `"loose"` \| `"record"` | How to handle empty objects (default: `"loose"`) |
 | `includeDescriptions` | `boolean` | Include JSDoc comments |
 | `useDescribe` | `boolean` | Add `.describe()` calls |
 | `defaultNullable` | `boolean` | Treat properties as nullable by default when not explicitly specified (default: `false`) |
@@ -314,6 +315,43 @@ const userSchema = z.looseObject({
 });
 ```
 
+## Empty Object Behavior
+
+When OpenAPI schemas define an object without any properties (e.g., `type: object` with no `properties`), the generator needs to decide how to represent it. The `emptyObjectBehavior` option controls this:
+
+### Loose (default)
+Uses `z.looseObject({})` which allows any additional properties:
+
+```typescript
+// OpenAPI: { type: object }
+const metadataSchema = z.looseObject({});
+
+// Accepts: {}, { foo: "bar" }, { any: "properties" }
+```
+
+### Strict
+Uses `z.strictObject({})` which rejects any properties:
+
+```typescript
+// OpenAPI: { type: object }
+const emptySchema = z.strictObject({});
+
+// Accepts: {}
+// Rejects: { foo: "bar" }
+```
+
+### Record
+Uses `z.record(z.string(), z.unknown())` which treats it as an arbitrary key-value map:
+
+```typescript
+// OpenAPI: { type: object }
+const mapSchema = z.record(z.string(), z.unknown());
+
+// Accepts: {}, { foo: "bar" }, { any: "properties" }
+```
+
+> **Note:** The `mode` option controls how top-level schema definitions are wrapped, while `emptyObjectBehavior` controls how nested empty objects (properties without defined structure) are generated. These are independent settings.
+
 ## Examples
 
 ### Input OpenAPI YAML
@@ -642,55 +680,74 @@ export default defineConfig({
 });
 ```
 
+**Important:** `defaultNullable` only applies to **primitive property values** within objects. It does NOT apply to:
+
+- **Top-level schema definitions** - Schemas are not made nullable at the definition level
+- **Schema references (`$ref`)** - References preserve the nullability of the target schema; add explicit `nullable: true` if needed
+- **Enum values** - Enums define discrete values and are not nullable by default
+- **Const/literal values** - Literals are exact values and are not nullable by default
+
 **Behavior comparison:**
 
 | Schema Property | `defaultNullable: false` (default) | `defaultNullable: true` |
 |-----------------|-------------------------------------|-------------------------|
 | `nullable: true` | `.nullable()` | `.nullable()` |
 | `nullable: false` | No `.nullable()` | No `.nullable()` |
-| No `nullable` specified | No `.nullable()` | `.nullable()` |
+| No annotation (primitive) | No `.nullable()` | `.nullable()` |
+| No annotation (`$ref`) | No `.nullable()` | No `.nullable()` |
+| No annotation (enum) | No `.nullable()` | No `.nullable()` |
+| No annotation (const) | No `.nullable()` | No `.nullable()` |
 
 **Example:**
 
 ```yaml
-User:
-  type: object
-  properties:
-    id:
-      type: integer
-    name:
-      type: string
-    email:
-      type: string
-      nullable: true
-    phone:
+components:
+  schemas:
+    Status:
       type: string
-      nullable: false
+      enum: [active, inactive]
+    User:
+      type: object
+      properties:
+        id:
+          type: integer
+        name:
+          type: string
+        status:
+          $ref: '#/components/schemas/Status'
+        nullableStatus:
+          allOf:
+            - $ref: '#/components/schemas/Status'
+          nullable: true
 ```
 
 **With `defaultNullable: false` (default):**
 ```typescript
+export const statusSchema = z.enum(["active", "inactive"]);
+
 export const userSchema = z.object({
   id: z.number().int(),
-  name: z.string(),           // Not nullable (no annotation)
-  email: z.string().nullable(), // Explicitly nullable
-  phone: z.string(),           // Explicitly not nullable
+  name: z.string(),              // Not nullable (no annotation)
+  status: statusSchema,          // Not nullable ($ref)
+  nullableStatus: statusSchema.nullable(), // Explicitly nullable
 });
 ```
 
 **With `defaultNullable: true`:**
 ```typescript
+export const statusSchema = z.enum(["active", "inactive"]);
+
 export const userSchema = z.object({
-  id: z.number().int().nullable(),  // Nullable by default
-  name: z.string().nullable(),       // Nullable by default
-  email: z.string().nullable(),      // Explicitly nullable
-  phone: z.string(),                 // Explicitly NOT nullable (respected)
+  id: z.number().int().nullable(),  // Nullable (primitive)
+  name: z.string().nullable(),       // Nullable (primitive)
+  status: statusSchema,              // NOT nullable ($ref - must be explicit)
+  nullableStatus: statusSchema.nullable(), // Explicitly nullable
 });
 ```
 
 ### Schema Composition
 
-- `allOf` → `.merge()` for objects, `.and()` for primitives
+- `allOf` → `.extend()` for objects (Zod v4), `.and()` for primitives
 - `oneOf`, `anyOf` → `z.union()` or `z.discriminatedUnion()`
 - `$ref` → Proper schema references
 
@@ -1140,11 +1197,11 @@ export const flexibleMetadataSchema = z
 
 ### Schema Composition
 
-#### AllOf - Smart Merging
+#### AllOf - Smart Extending
 
-Uses `.merge()` for objects, `.and()` for primitives:
+Uses `.extend()` for objects (Zod v4 compliant - `.merge()` is deprecated), `.and()` for primitives:
 
-**Object Merging:**
+**Object Extending:**
 ```yaml
 User:
   allOf:
@@ -1161,10 +1218,10 @@ User:
 **Generated:**
 ```typescript
 export const userSchema = baseEntitySchema
-  .merge(timestampedSchema)
-  .merge(z.object({
+  .extend(timestampedSchema.shape)
+  .extend(z.object({
     username: z.string()
-  }));
+  }).shape);
 ```
 
 #### OneOf / AnyOf
@@ -1286,7 +1343,7 @@ export const statusCodeSchema = z.enum(["200", "201", "400", "404", "500"]);
 | const | ✅ | ✅ | `z.literal()` |
 | nullable (property) | ✅ | ✅ | `.nullable()` |
 | nullable (type array) | ❌ | ✅ | `.nullable()` |
-| allOf (objects) | ✅ | ✅ | `.merge()` |
+| allOf (objects) | ✅ | ✅ | `.extend()` |
 | allOf (primitives) | ✅ | ✅ | `.and()` |
 | oneOf/anyOf | ✅ | ✅ | `z.union()` |
 | discriminators | ✅ | ✅ | `z.discriminatedUnion()` |

package/dist/cli.js

@@ -5480,12 +5480,56 @@ function generateArrayValidation(schema, context) {
 
 // src/validators/composition-validator.ts
 init_cjs_shims();
+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())`);
@@ -5500,25 +5544,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);
 }
 
 // src/validators/number-validator.ts
@@ -6200,6 +6321,15 @@ var _PropertyGenerator = class _PropertyGenerator {
     }
     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
@@ -6277,7 +6407,7 @@ var _PropertyGenerator = class _PropertyGenerator {
     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) {
@@ -6304,7 +6434,11 @@ var _PropertyGenerator = class _PropertyGenerator {
     if ((this.context.schemaType === "request" || this.context.schemaType === "response") && schema.properties) {
       schema = this.filterNestedProperties(schema);
     }
-    const effectiveDefaultNullable = isTopLevel ? false : this.context.defaultNullable;
+    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);
@@ -6357,7 +6491,11 @@ var _PropertyGenerator = class _PropertyGenerator {
       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) {
@@ -6373,7 +6511,8 @@ var _PropertyGenerator = class _PropertyGenerator {
         nullable,
         {
           generatePropertySchema: this.generatePropertySchema.bind(this),
-          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this)
+          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
+          resolveSchemaRef: this.resolveSchemaRef.bind(this)
         },
         {
           passthrough: needsPassthrough,
@@ -6394,7 +6533,8 @@ var _PropertyGenerator = class _PropertyGenerator {
         nullable,
         {
           generatePropertySchema: this.generatePropertySchema.bind(this),
-          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this)
+          resolveDiscriminatorMapping: this.resolveDiscriminatorMapping.bind(this),
+          resolveSchemaRef: this.resolveSchemaRef.bind(this)
         },
         {
           passthrough: needsPassthrough,
@@ -6457,7 +6597,17 @@ var _PropertyGenerator = class _PropertyGenerator {
           );
           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;
@@ -6472,6 +6622,44 @@ var _PropertyGenerator = class _PropertyGenerator {
     }
     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 = {
@@ -6616,6 +6804,60 @@ function formatFilterStatistics(stats) {
   return lines.join("\n");
 }
 
+// src/utils/ref-resolver.ts
+init_cjs_shims();
+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;
+}
+
 // src/openapi-generator.ts
 var OpenApiGenerator = class {
   constructor(options) {
@@ -6625,7 +6867,7 @@ var OpenApiGenerator = class {
     this.schemaUsageMap = /* @__PURE__ */ new Map();
     this.needsZodImport = true;
     this.filterStats = createFilterStatistics();
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     if (!options.input) {
       throw new ConfigurationError("Input path is required", { providedOptions: options });
     }
@@ -6636,18 +6878,19 @@ var OpenApiGenerator = class {
       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,
       stripPathPrefix: options.stripPathPrefix,
-      showStats: (_d = options.showStats) != null ? _d : true,
+      showStats: (_e = options.showStats) != null ? _e : true,
       request: options.request,
       response: options.response,
       operationFilters: options.operationFilters,
       ignoreHeaders: options.ignoreHeaders,
-      cacheSize: (_e = options.cacheSize) != null ? _e : 1e3,
-      batchSize: (_f = options.batchSize) != null ? _f : 10,
+      cacheSize: (_f = options.cacheSize) != null ? _f : 1e3,
+      batchSize: (_g = options.batchSize) != null ? _g : 10,
       customDateTimeFormatRegex: options.customDateTimeFormatRegex
     };
     if (this.options.cacheSize) {
@@ -6718,7 +6961,8 @@ var OpenApiGenerator = class {
       mode: this.requestOptions.mode,
       includeDescriptions: this.requestOptions.includeDescriptions,
       useDescribe: this.requestOptions.useDescribe,
-      defaultNullable: (_g = this.options.defaultNullable) != null ? _g : false,
+      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
@@ -7072,7 +7316,7 @@ var OpenApiGenerator = class {
    * Generate schema for a component
    */
   generateComponentSchema(name, schema) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (!this.schemaDependencies.has(name)) {
       this.schemaDependencies.set(name, /* @__PURE__ */ new Set());
     }
@@ -7105,6 +7349,7 @@ ${typeCode}`;
       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
@@ -7121,7 +7366,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);
-            (_c = this.schemaDependencies.get(name)) == null ? void 0 : _c.add(depName);
+            (_d = this.schemaDependencies.get(name)) == null ? void 0 : _d.add(depName);
           }
         }
       }
@@ -7145,10 +7390,8 @@ ${typeCode}`;
         if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
           continue;
         }
-        if (!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) {
@@ -7284,10 +7527,8 @@ ${propsCode}
         if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
           continue;
         }
-        if (!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) {
@@ -7377,13 +7618,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") {
@@ -7408,11 +7659,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