@cerios/openapi-to-zod 0.5.3 → 0.6.0

package/README.md

@@ -6,7 +6,7 @@ Transform OpenAPI YAML specifications into Zod v4 compliant schemas with full Ty
 
 - ✅ **Zod v4 Compatible**: Uses latest Zod features, no deprecated methods
 - 📝 **TypeScript Types**: Automatically generates TypeScript types from schemas using `z.infer`
-- 🎯 **Enums**: Creates proper TypeScript enums with PascalCase properties
+- 🎯 **Zod Enums**: Creates Zod enum schemas from OpenAPI enums
 - 🔧 **Flexible Modes**: Strict, normal, or loose validation
 - 📐 **Format Support**: Full support for string formats (uuid, email, url, date, etc.)
 - 🎨 **camelCase Schemas**: Schemas follow camelCase naming with Schema suffix
@@ -128,12 +128,6 @@ export default defineConfig({
 
 **openapi-to-zod.config.json:**
 
-```json
-{
-  "defaults": {
-    "mode": "strict",
-    "includeDescriptions": true,
-    "enumType": "zod",
 ```json
 {
   "defaults": {
@@ -218,15 +212,13 @@ openapi-to-zod
 | `output` | `string` | Output TypeScript file path (required) |
 | `mode` | `"strict"` \| `"normal"` \| `"loose"` | Validation mode |
 | `includeDescriptions` | `boolean` | Include JSDoc comments |
-| `enumType` | `"zod"` \| `"typescript"` | Enum generation type |
 | `useDescribe` | `boolean` | Add `.describe()` calls |
 | `schemaType` | `"all"` \| `"request"` \| `"response"` | Schema filtering |
 | `prefix` | `string` | Prefix for schema names |
 | `suffix` | `string` | Suffix for schema names |
 | `showStats` | `boolean` | Include generation statistics |
-| `nativeEnumType` | `"union"` \| `"enum"` | Native enum type when using TypeScript enums |
-| `request` | `object` | Request-specific options (mode, typeMode, enumType, etc.) |
-| `response` | `object` | Response-specific options (mode, enumType, etc.) |
+| `request` | `object` | Request-specific options (mode, includeDescriptions, etc.) |
+| `response` | `object` | Response-specific options (mode, includeDescriptions, etc.) |
 
 ### Batch Execution
 
@@ -440,10 +432,10 @@ OpenAPI's `nullable: true` is converted to `.nullable()`
 
 ### Enums
 
-Enums are generated as TypeScript enums with:
-- PascalCase property names
-- Original string values
+Enums are generated as Zod enums with:
+- Proper string value handling
 - Zod schema using `z.enum()`
+- TypeScript type inference from the Zod schema
 
 ## Schema Naming
 
@@ -475,7 +467,6 @@ Statistics are **included by default** in generated files. Use `--no-stats` to d
 ```typescript
 // Generation Statistics:
 //   Total schemas: 42
-//   Enums: 8
 //   Circular references: 3
 //   Discriminated unions: 5
 //   With constraints: 18
@@ -877,7 +868,7 @@ interface OpenApiGeneratorOptions {
 Comprehensive test suite with **364 passing tests** covering:
 
 - ✅ **Basic Schema Generation** (14 tests) - Core OpenAPI types, references, nested objects
-- ✅ **Enum Generation** (10 tests) - TypeScript enums, Zod enums, PascalCase conversion
+- ✅ **Enum Generation** (4 tests) - Zod enum generation and handling
 - ✅ **Circular References** (5 tests) - Self-references, mutual references, validation
 - ✅ **Format Support** (9 tests) - UUID, email, URL, date-time, and 15+ other formats
 - ✅ **Validation Modes** (7 tests) - Strict, normal, loose object validation

package/dist/cli.js

@@ -5054,34 +5054,11 @@ function resolveRef(ref) {
 
 // src/generators/enum-generator.ts
 function generateEnum(name, values, options) {
-  const enumName = name.endsWith("EnumOptions") ? name.replace("EnumOptions", "Enum") : `${name}Enum`;
   const schemaName = `${toCamelCase(name, options)}Schema`;
-  if (options.enumType === "typescript") {
-    const usedKeys = /* @__PURE__ */ new Set();
-    const enumEntries = values.map((value) => {
-      let key = toPascalCase(value);
-      if (usedKeys.has(key)) {
-        let counter = 2;
-        while (usedKeys.has(`${key}${counter}`)) {
-          counter++;
-        }
-        key = `${key}${counter}`;
-      }
-      usedKeys.add(key);
-      const stringValue = typeof value === "string" ? `"${value}"` : value;
-      return `  ${key} = ${stringValue},`;
-    }).join("\n");
-    const enumCode = `export enum ${enumName} {
-${enumEntries}
-}`;
-    const schemaCode2 = `export const ${schemaName} = z.nativeEnum(${enumName});`;
-    const typeCode2 = `export type ${name} = z.infer<typeof ${schemaName}>;`;
-    return { enumCode, schemaCode: schemaCode2, typeCode: typeCode2 };
-  }
   const enumValues = values.map((v) => `"${v}"`).join(", ");
   const schemaCode = `export const ${schemaName} = z.enum([${enumValues}]);`;
   const typeCode = `export type ${name} = z.infer<typeof ${schemaName}>;`;
-  return { enumCode: null, schemaCode, typeCode };
+  return { schemaCode, typeCode };
 }
 
 // src/generators/jsdoc-generator.ts
@@ -6362,12 +6339,9 @@ var OpenApiGenerator = class {
   constructor(options) {
     this.schemas = /* @__PURE__ */ new Map();
     this.types = /* @__PURE__ */ new Map();
-    this.enums = /* @__PURE__ */ new Map();
-    this.nativeEnums = /* @__PURE__ */ new Map();
     this.schemaDependencies = /* @__PURE__ */ new Map();
     this.schemaUsageMap = /* @__PURE__ */ new Map();
-    this.schemaTypeModeMap = /* @__PURE__ */ new Map();
-    this.needsZodImport = false;
+    this.needsZodImport = true;
     this.filterStats = createFilterStatistics();
     var _a, _b, _c;
     if (!options.input) {
@@ -6378,13 +6352,11 @@ var OpenApiGenerator = class {
       input: options.input,
       output: options.output,
       includeDescriptions: (_a = options.includeDescriptions) != null ? _a : true,
-      enumType: options.enumType || "zod",
       useDescribe: (_b = options.useDescribe) != null ? _b : false,
       schemaType: options.schemaType || "all",
       prefix: options.prefix,
       suffix: options.suffix,
       showStats: (_c = options.showStats) != null ? _c : true,
-      nativeEnumType: options.nativeEnumType || "union",
       request: options.request,
       response: options.response,
       operationFilters: options.operationFilters
@@ -6444,7 +6416,6 @@ var OpenApiGenerator = class {
     this.requestOptions = this.resolveOptionsForContext("request");
     this.responseOptions = this.resolveOptionsForContext("response");
     this.analyzeSchemaUsage();
-    this.determineSchemaTypeModes();
     this.propertyGenerator = new PropertyGenerator({
       spec: this.spec,
       schemaDependencies: this.schemaDependencies,
@@ -6452,8 +6423,6 @@ var OpenApiGenerator = class {
       mode: this.requestOptions.mode,
       includeDescriptions: this.requestOptions.includeDescriptions,
       useDescribe: this.requestOptions.useDescribe,
-      typeMode: this.requestOptions.typeMode,
-      nativeEnumType: this.requestOptions.nativeEnumType,
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
@@ -6469,25 +6438,6 @@ var OpenApiGenerator = class {
     if (!((_a = this.spec.components) == null ? void 0 : _a.schemas)) {
       throw new SpecValidationError("No schemas found in OpenAPI spec", { filePath: this.options.input });
     }
-    for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
-      if (schema.enum) {
-        const context = this.schemaUsageMap.get(name);
-        const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
-        if (resolvedOptions.enumType === "typescript") {
-          this.generateNativeEnum(name, schema);
-        } else {
-          const { enumCode } = generateEnum(name, schema.enum, {
-            enumType: "zod",
-            prefix: this.options.prefix,
-            suffix: this.options.suffix
-          });
-          if (enumCode) {
-            this.enums.set(name, enumCode);
-            this.needsZodImport = true;
-          }
-        }
-      }
-    }
     for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
       this.generateComponentSchema(name, schema);
     }
@@ -6504,22 +6454,11 @@ var OpenApiGenerator = class {
       output.push('import { z } from "zod";');
       output.push("");
     }
-    if (this.nativeEnums.size > 0) {
-      output.push("// Native Enums");
-      for (const enumCode of this.nativeEnums.values()) {
-        output.push(enumCode);
-        output.push("");
-      }
-    }
     output.push("// Schemas and Types");
     for (const name of orderedSchemaNames) {
-      const enumCode = this.enums.get(name);
       const schemaCode = this.schemas.get(name);
       const typeCode = this.types.get(name);
-      if (enumCode) {
-        output.push(enumCode);
-        output.push("");
-      } else if (schemaCode) {
+      if (schemaCode) {
         output.push(schemaCode);
         if (!schemaCode.includes(`export type ${name}`)) {
           const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
@@ -6561,21 +6500,14 @@ var OpenApiGenerator = class {
   /**
    * Resolve options for a specific context (request or response)
    * Nested options silently override root-level options
-   * Response schemas always use 'inferred' mode (Zod schemas)
    */
   resolveOptionsForContext(context) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a, _b, _c, _d, _e, _f;
     const contextOptions = context === "request" ? this.options.request : this.options.response;
-    const nativeEnumType = context === "request" ? (_c = (_b = (_a = this.options.request) == null ? void 0 : _a.nativeEnumType) != null ? _b : this.options.nativeEnumType) != null ? _c : "union" : (_d = this.options.nativeEnumType) != null ? _d : "union";
     return {
-      mode: (_f = (_e = contextOptions == null ? void 0 : contextOptions.mode) != null ? _e : this.options.mode) != null ? _f : "normal",
-      enumType: (_h = (_g = contextOptions == null ? void 0 : contextOptions.enumType) != null ? _g : this.options.enumType) != null ? _h : "zod",
-      useDescribe: (_j = (_i = contextOptions == null ? void 0 : contextOptions.useDescribe) != null ? _i : this.options.useDescribe) != null ? _j : false,
-      includeDescriptions: (_l = (_k = contextOptions == null ? void 0 : contextOptions.includeDescriptions) != null ? _k : this.options.includeDescriptions) != null ? _l : true,
-      // Response schemas always use 'inferred' mode (Zod schemas are required)
-      // Request schemas can optionally use 'native' mode
-      typeMode: context === "response" ? "inferred" : (_n = (_m = this.options.request) == null ? void 0 : _m.typeMode) != null ? _n : "inferred",
-      nativeEnumType
+      mode: (_b = (_a = contextOptions == null ? void 0 : contextOptions.mode) != null ? _a : this.options.mode) != null ? _b : "normal",
+      useDescribe: (_d = (_c = contextOptions == null ? void 0 : contextOptions.useDescribe) != null ? _c : this.options.useDescribe) != null ? _d : false,
+      includeDescriptions: (_f = (_e = contextOptions == null ? void 0 : contextOptions.includeDescriptions) != null ? _e : this.options.includeDescriptions) != null ? _f : true
     };
   }
   /**
@@ -6766,28 +6698,6 @@ var OpenApiGenerator = class {
       detectCycle(name);
     }
   }
-  /**
-   * Determine the typeMode for each schema based on its usage context
-   * Response schemas always use 'inferred' mode
-   */
-  determineSchemaTypeModes() {
-    var _a;
-    for (const [name] of Object.entries(((_a = this.spec.components) == null ? void 0 : _a.schemas) || {})) {
-      const context = this.schemaUsageMap.get(name);
-      if (context === "request") {
-        this.schemaTypeModeMap.set(name, this.requestOptions.typeMode);
-      } else if (context === "response") {
-        this.schemaTypeModeMap.set(name, "inferred");
-      } else if (context === "both") {
-        this.schemaTypeModeMap.set(name, "inferred");
-      } else {
-        this.schemaTypeModeMap.set(name, "inferred");
-      }
-      if (this.schemaTypeModeMap.get(name) === "inferred") {
-        this.needsZodImport = true;
-      }
-    }
-  }
   /**
    * Validate the OpenAPI specification
    */
@@ -6863,80 +6773,54 @@ var OpenApiGenerator = class {
     if (!this.schemaDependencies.has(name)) {
       this.schemaDependencies.set(name, /* @__PURE__ */ new Set());
     }
-    const typeMode = this.schemaTypeModeMap.get(name) || "inferred";
     const context = this.schemaUsageMap.get(name);
     const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
     if (schema.enum) {
-      const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      if (resolvedOptions.enumType === "typescript") {
-        const { schemaCode, typeCode } = generateEnum(name, schema.enum, {
-          enumType: "typescript",
-          prefix: this.options.prefix,
-          suffix: this.options.suffix
-        });
-        const enumSchemaCode = `${jsdoc}${schemaCode}
-${typeCode}`;
-        this.schemas.set(name, enumSchemaCode);
-      } else {
-        const { enumCode, schemaCode, typeCode } = generateEnum(name, schema.enum, {
-          enumType: "zod",
-          prefix: this.options.prefix,
-          suffix: this.options.suffix
-        });
-        if (enumCode) {
-          this.enums.set(name, enumCode);
-        }
-        const enumSchemaCode = `${jsdoc}${schemaCode}
+      const jsdoc2 = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
+      const { schemaCode, typeCode } = generateEnum(name, schema.enum, {
+        prefix: this.options.prefix,
+        suffix: this.options.suffix
+      });
+      const enumSchemaCode = `${jsdoc2}${schemaCode}
 ${typeCode}`;
-        this.schemas.set(name, enumSchemaCode);
-      }
+      this.schemas.set(name, enumSchemaCode);
       return;
     }
-    if (typeMode === "native") {
-      const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      const jsdocWithConstraints = this.addConstraintsToJSDoc(jsdoc, schema, resolvedOptions.includeDescriptions);
-      const typeDefinition = this.generateNativeTypeDefinition(schema, name);
-      const typeCode = `${jsdocWithConstraints}export type ${name} = ${typeDefinition};`;
-      this.types.set(name, typeCode);
-    } else {
-      const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
-      const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref) {
-        const refName = resolveRef(schema.allOf[0].$ref);
-        (_a = this.schemaDependencies.get(name)) == null ? void 0 : _a.add(refName);
-      }
-      this.propertyGenerator = new PropertyGenerator({
-        spec: this.spec,
-        schemaDependencies: this.schemaDependencies,
-        schemaType: this.options.schemaType || "all",
-        mode: resolvedOptions.mode,
-        includeDescriptions: resolvedOptions.includeDescriptions,
-        useDescribe: resolvedOptions.useDescribe,
-        typeMode: resolvedOptions.typeMode,
-        nativeEnumType: resolvedOptions.nativeEnumType,
-        namingOptions: {
-          prefix: this.options.prefix,
-          suffix: this.options.suffix
-        }
-      });
-      const isAlias = !!(schema.$ref && !schema.properties && !schema.allOf && !schema.oneOf && !schema.anyOf);
-      const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, isAlias);
-      const zodSchemaCode = `${jsdoc}export const ${schemaName} = ${zodSchema};`;
-      if (zodSchema.includes("z.discriminatedUnion(")) {
-        const match = zodSchema.match(/z\.discriminatedUnion\([^,]+,\s*\[([^\]]+)\]/);
-        if (match) {
-          const refs = match[1].split(",").map((ref) => ref.trim());
-          for (const ref of refs) {
-            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);
-            }
+    const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+    const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
+    if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref) {
+      const refName = resolveRef(schema.allOf[0].$ref);
+      (_a = this.schemaDependencies.get(name)) == null ? void 0 : _a.add(refName);
+    }
+    this.propertyGenerator = new PropertyGenerator({
+      spec: this.spec,
+      schemaDependencies: this.schemaDependencies,
+      schemaType: this.options.schemaType || "all",
+      mode: resolvedOptions.mode,
+      includeDescriptions: resolvedOptions.includeDescriptions,
+      useDescribe: resolvedOptions.useDescribe,
+      namingOptions: {
+        prefix: this.options.prefix,
+        suffix: this.options.suffix
+      }
+    });
+    const isAlias = !!(schema.$ref && !schema.properties && !schema.allOf && !schema.oneOf && !schema.anyOf);
+    const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, isAlias);
+    const zodSchemaCode = `${jsdoc}export const ${schemaName} = ${zodSchema};`;
+    if (zodSchema.includes("z.discriminatedUnion(")) {
+      const match = zodSchema.match(/z\.discriminatedUnion\([^,]+,\s*\[([^\]]+)\]/);
+      if (match) {
+        const refs = match[1].split(",").map((ref) => ref.trim());
+        for (const ref of refs) {
+          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);
           }
         }
       }
-      this.schemas.set(name, zodSchemaCode);
     }
+    this.schemas.set(name, zodSchemaCode);
   }
   /**
    * Generate query parameter schemas for each operation
@@ -7142,151 +7026,11 @@ ${propsCode}
     }
     return "z.unknown()";
   }
-  /**
-   * Generate native TypeScript enum
-   */
-  generateNativeEnum(name, schema) {
-    if (!schema.enum) return;
-    const context = this.schemaUsageMap.get(name);
-    const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
-    const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-    if (resolvedOptions.nativeEnumType === "enum") {
-      const enumName = `${name}Enum`;
-      const members = schema.enum.map((value) => {
-        const key = typeof value === "string" ? this.toEnumKey(value) : `N${value}`;
-        const val = typeof value === "string" ? `"${value}"` : value;
-        return `  ${key} = ${val}`;
-      }).join(",\n");
-      const enumCode = `${jsdoc}export enum ${enumName} {
-${members}
-}`;
-      this.nativeEnums.set(name, enumCode);
-      const typeCode = `export type ${name} = ${enumName};`;
-      this.types.set(name, typeCode);
-    } else {
-      const unionType = schema.enum.map((v) => typeof v === "string" ? `"${v}"` : v).join(" | ");
-      const typeCode = `${jsdoc}export type ${name} = ${unionType};`;
-      this.types.set(name, typeCode);
-    }
-  }
-  /**
-   * Convert string to valid enum key
-   */
-  toEnumKey(value) {
-    const cleaned = value.replace(/[^a-zA-Z0-9]/g, "_");
-    const pascalCase = cleaned.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-    return pascalCase || "Value";
-  }
-  /**
-   * Add constraint annotations to JSDoc for native types
-   */
-  addConstraintsToJSDoc(jsdoc, schema, includeDescriptions) {
-    if (!includeDescriptions) return jsdoc;
-    const constraints = [];
-    if (schema.minLength !== void 0) constraints.push(`@minLength ${schema.minLength}`);
-    if (schema.maxLength !== void 0) constraints.push(`@maxLength ${schema.maxLength}`);
-    if (schema.pattern) constraints.push(`@pattern ${schema.pattern}`);
-    if (schema.minimum !== void 0) constraints.push(`@minimum ${schema.minimum}`);
-    if (schema.maximum !== void 0) constraints.push(`@maximum ${schema.maximum}`);
-    if (schema.minItems !== void 0) constraints.push(`@minItems ${schema.minItems}`);
-    if (schema.maxItems !== void 0) constraints.push(`@maxItems ${schema.maxItems}`);
-    if (schema.minProperties !== void 0) constraints.push(`@minProperties ${schema.minProperties}`);
-    if (schema.maxProperties !== void 0) constraints.push(`@maxProperties ${schema.maxProperties}`);
-    if (schema.multipleOf !== void 0) constraints.push(`@multipleOf ${schema.multipleOf}`);
-    if (schema.format) constraints.push(`@format ${schema.format}`);
-    if (constraints.length === 0) return jsdoc;
-    if (jsdoc) {
-      const lines = jsdoc.trim().split("\n");
-      if (lines[0] === "/**" && lines[lines.length - 1] === " */") {
-        const newLines = [...lines.slice(0, -1), ...constraints.map((c) => ` * ${c}`), " */\n"];
-        return newLines.join("\n");
-      }
-      const content = jsdoc.replace("/** ", "").replace(" */\n", "");
-      return `/**
- * ${content}
-${constraints.map((c) => ` * ${c}`).join("\n")}
- */
-`;
-    }
-    return `/**
-${constraints.map((c) => ` * ${c}`).join("\n")}
- */
-`;
-  }
-  /**
-   * Generate native TypeScript type definition from OpenAPI schema
-   */
-  generateNativeTypeDefinition(schema, _schemaName) {
-    if (schema.$ref) {
-      return resolveRef(schema.$ref);
-    }
-    if (schema.const !== void 0) {
-      return typeof schema.const === "string" ? `"${schema.const}"` : String(schema.const);
-    }
-    const isNullable2 = schema.nullable || Array.isArray(schema.type) && schema.type.includes("null");
-    const wrapNullable2 = (type) => isNullable2 ? `(${type}) | null` : type;
-    const primaryType = Array.isArray(schema.type) ? schema.type.find((t) => t !== "null") : schema.type;
-    switch (primaryType) {
-      case "string":
-        return wrapNullable2("string");
-      case "number":
-      case "integer":
-        return wrapNullable2("number");
-      case "boolean":
-        return wrapNullable2("boolean");
-      case "array":
-        if (schema.items) {
-          const itemType = this.generateNativeTypeDefinition(schema.items);
-          return wrapNullable2(`${itemType}[]`);
-        }
-        return wrapNullable2("unknown[]");
-      case "object":
-        return wrapNullable2(this.generateObjectType(schema));
-      default:
-        if (schema.allOf) {
-          const types = schema.allOf.map((s) => this.generateNativeTypeDefinition(s));
-          return wrapNullable2(types.join(" & "));
-        }
-        if (schema.oneOf || schema.anyOf) {
-          const schemas = schema.oneOf || schema.anyOf || [];
-          const types = schemas.map((s) => this.generateNativeTypeDefinition(s));
-          return wrapNullable2(types.join(" | "));
-        }
-        return wrapNullable2("unknown");
-    }
-  }
-  /**
-   * Generate TypeScript object type definition
-   */
-  generateObjectType(schema) {
-    if (!schema.properties || Object.keys(schema.properties).length === 0) {
-      return "Record<string, unknown>";
-    }
-    const context = this.schemaUsageMap.get(schema.$ref ? resolveRef(schema.$ref) : "");
-    const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
-    const required = new Set(schema.required || []);
-    const props = [];
-    for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      const propType = this.generateNativeTypeDefinition(propSchema);
-      const optional = !required.has(propName) ? "?" : "";
-      let propJsdoc = generateJSDoc(propSchema, propName, { includeDescriptions: resolvedOptions.includeDescriptions });
-      if (resolvedOptions.includeDescriptions && !propJsdoc) {
-        propJsdoc = this.addConstraintsToJSDoc("", propSchema, resolvedOptions.includeDescriptions);
-      } else if (propJsdoc && resolvedOptions.includeDescriptions) {
-        propJsdoc = this.addConstraintsToJSDoc(propJsdoc, propSchema, resolvedOptions.includeDescriptions);
-      }
-      if (propJsdoc) {
-        const cleanJsdoc = propJsdoc.trimEnd();
-        props.push(`  ${cleanJsdoc}
-  ${propName}${optional}: ${propType};`);
-      } else {
-        props.push(`  ${propName}${optional}: ${propType};`);
-      }
-    }
-    return `{
-${props.join("\n")}
-}`;
-  }
+  // 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
@@ -7298,9 +7042,6 @@ ${props.join("\n")}
     const aliases = [];
     const circularDeps = /* @__PURE__ */ new Set();
     const codeCache = /* @__PURE__ */ new Map();
-    for (const [name, code] of this.enums) {
-      codeCache.set(name, code);
-    }
     for (const [name, code] of this.schemas) {
       codeCache.set(name, code);
     }
@@ -7325,7 +7066,7 @@ ${props.join("\n")}
       const deps = this.schemaDependencies.get(name);
       if (deps && deps.size > 0) {
         for (const dep of deps) {
-          if (this.enums.has(dep) || this.schemas.has(dep) || this.types.has(dep)) {
+          if (this.schemas.has(dep) || this.types.has(dep)) {
             visit(dep);
           }
         }
@@ -7336,7 +7077,7 @@ ${props.join("\n")}
         sorted.push(name);
       }
     };
-    const allNames = /* @__PURE__ */ new Set([...this.enums.keys(), ...this.schemas.keys(), ...this.types.keys()]);
+    const allNames = /* @__PURE__ */ new Set([...this.schemas.keys(), ...this.types.keys()]);
     for (const name of allNames) {
       visit(name);
     }
@@ -7354,7 +7095,6 @@ ${props.join("\n")}
   generateStats() {
     const stats = {
       totalSchemas: this.schemas.size,
-      enums: this.enums.size,
       withCircularRefs: 0,
       withDiscriminators: 0,
       withConstraints: 0
@@ -7369,7 +7109,6 @@ ${props.join("\n")}
     const output = [
       "// Generation Statistics:",
       `//   Total schemas: ${stats.totalSchemas}`,
-      `//   Enums: ${stats.enums}`,
       `//   Circular references: ${stats.withCircularRefs}`,
       `//   Discriminated unions: ${stats.withDiscriminators}`,
       `//   With constraints: ${stats.withConstraints}`
@@ -7491,15 +7230,10 @@ function getBatchExitCode(summary) {
 init_cjs_shims();
 var import_cosmiconfig = require("cosmiconfig");
 var import_zod = require("zod");
-var TypeModeSchema = import_zod.z.enum(["inferred", "native"]);
-var NativeEnumTypeSchema = import_zod.z.enum(["union", "enum"]);
 var RequestResponseOptionsSchema = import_zod.z.strictObject({
   mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
-  enumType: import_zod.z.enum(["zod", "typescript"]).optional(),
   useDescribe: import_zod.z.boolean().optional(),
-  includeDescriptions: import_zod.z.boolean().optional(),
-  typeMode: TypeModeSchema.optional(),
-  nativeEnumType: NativeEnumTypeSchema.optional()
+  includeDescriptions: import_zod.z.boolean().optional()
 });
 var OperationFiltersSchema = import_zod.z.strictObject({
   includeTags: import_zod.z.array(import_zod.z.string()).optional(),
@@ -7517,13 +7251,11 @@ var OpenApiGeneratorOptionsSchema = import_zod.z.strictObject({
   input: import_zod.z.string(),
   output: import_zod.z.string(),
   includeDescriptions: import_zod.z.boolean().optional(),
-  enumType: import_zod.z.enum(["zod", "typescript"]).optional(),
   useDescribe: import_zod.z.boolean().optional(),
   schemaType: import_zod.z.enum(["all", "request", "response"]).optional(),
   prefix: import_zod.z.string().optional(),
   suffix: import_zod.z.string().optional(),
   showStats: import_zod.z.boolean().optional(),
-  nativeEnumType: NativeEnumTypeSchema.optional(),
   request: RequestResponseOptionsSchema.optional(),
   response: RequestResponseOptionsSchema.optional(),
   name: import_zod.z.string().optional(),
@@ -7533,13 +7265,11 @@ var ConfigFileSchema = import_zod.z.strictObject({
   defaults: import_zod.z.strictObject({
     mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
     includeDescriptions: import_zod.z.boolean().optional(),
-    enumType: import_zod.z.enum(["zod", "typescript"]).optional(),
     useDescribe: import_zod.z.boolean().optional(),
     schemaType: import_zod.z.enum(["all", "request", "response"]).optional(),
     prefix: import_zod.z.string().optional(),
     suffix: import_zod.z.string().optional(),
     showStats: import_zod.z.boolean().optional(),
-    nativeEnumType: NativeEnumTypeSchema.optional(),
     request: RequestResponseOptionsSchema.optional(),
     response: RequestResponseOptionsSchema.optional(),
     operationFilters: OperationFiltersSchema.optional()
@@ -7635,7 +7365,6 @@ function mergeConfigWithDefaults(config) {
       // Apply defaults first
       mode: defaults.mode,
       includeDescriptions: defaults.includeDescriptions,
-      enumType: defaults.enumType,
       useDescribe: defaults.useDescribe,
       schemaType: defaults.schemaType,
       prefix: defaults.prefix,
@@ -7834,7 +7563,7 @@ async function initConfigFile() {
     {
       type: "confirm",
       name: "includeDefaults",
-      message: "Include commonly-used defaults? (mode: strict, includeDescriptions: true, showStats: false)",
+      message: "Include commonly-used recommended defaults?",
       initial: true
     }
   ]);
@@ -7855,7 +7584,9 @@ export default defineConfig({
   defaults: {
     mode: 'strict',
     includeDescriptions: true,
+	useDescribe: false,
     showStats: false,
+	schemaType: 'all',
   },
   specs: [
     {