@cerios/openapi-to-zod 0.5.3 → 1.0.0

package/dist/cli.mjs

@@ -5016,6 +5016,125 @@ var init_errors = __esm({
   }
 });
 
+// src/batch-executor.ts
+async function processSpec(spec, index, total, createGenerator) {
+  const specInput = spec.input || "spec";
+  const specOutput = spec.output || "output";
+  console.log(`Processing [${index + 1}/${total}] ${specInput}...`);
+  try {
+    const generator = createGenerator(spec);
+    generator.generate();
+    return {
+      spec,
+      success: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u2717 Failed to generate ${specOutput}: ${errorMessage}`);
+    return {
+      spec,
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+async function executeParallel(specs, createGenerator, batchSize) {
+  console.log(`
+Executing ${specs.length} specification(s) in parallel (batch size: ${batchSize})...
+`);
+  const results = [];
+  for (let i = 0; i < specs.length; i += batchSize) {
+    const batch = specs.slice(i, Math.min(i + batchSize, specs.length));
+    const batchPromises = batch.map(
+      (spec, batchIndex) => processSpec(spec, i + batchIndex, specs.length, createGenerator)
+    );
+    const batchResults = await Promise.allSettled(batchPromises);
+    for (let j = 0; j < batchResults.length; j++) {
+      const result = batchResults[j];
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        results.push({
+          spec: batch[j],
+          success: false,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+        });
+      }
+    }
+  }
+  return results;
+}
+async function executeSequential(specs, createGenerator) {
+  console.log(`
+Executing ${specs.length} spec(s) sequentially...
+`);
+  const results = [];
+  for (let i = 0; i < specs.length; i++) {
+    const result = await processSpec(specs[i], i, specs.length, createGenerator);
+    results.push(result);
+  }
+  return results;
+}
+function printSummary(summary) {
+  console.log(`
+${"=".repeat(50)}`);
+  console.log("Batch Execution Summary");
+  console.log("=".repeat(50));
+  console.log(`Total specs: ${summary.total}`);
+  console.log(`Successful: ${summary.successful}`);
+  console.log(`Failed: ${summary.failed}`);
+  if (summary.failed > 0) {
+    console.log("\nFailed specs:");
+    for (const result of summary.results) {
+      if (!result.success) {
+        const specInput = result.spec.input || "spec";
+        console.error(`  \u2717 ${specInput}`);
+        console.error(`    Error: ${result.error}`);
+      }
+    }
+  }
+  console.log(`${"=".repeat(50)}
+`);
+}
+async function executeBatch(specs, executionMode = "parallel", createGenerator, batchSize) {
+  if (specs.length === 0) {
+    throw new ConfigurationError("No specs provided for batch execution", { specsCount: 0, executionMode });
+  }
+  let results = [];
+  try {
+    results = executionMode === "parallel" ? await executeParallel(specs, createGenerator, batchSize) : await executeSequential(specs, createGenerator);
+    const summary = {
+      total: results.length,
+      successful: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      results
+    };
+    printSummary(summary);
+    return summary;
+  } finally {
+    if (results.length > batchSize) {
+      for (const result of results) {
+        if (result.spec) {
+          result.spec = null;
+        }
+      }
+      if (global.gc) {
+        global.gc();
+      }
+    }
+  }
+}
+function getBatchExitCode(summary) {
+  return summary.failed > 0 ? 1 : 0;
+}
+var init_batch_executor = __esm({
+  "src/batch-executor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+  }
+});
+
 // src/utils/name-utils.ts
 function toCamelCase(str, options) {
   let name = str.charAt(0).toLowerCase() + str.slice(1);
@@ -5053,34 +5172,11 @@ var init_name_utils = __esm({
 
 // 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 };
 }
 var init_enum_generator = __esm({
   "src/generators/enum-generator.ts"() {
@@ -5204,6 +5300,9 @@ var init_lru_cache = __esm({
         this.cache = /* @__PURE__ */ new Map();
         this.maxSize = maxSize;
       }
+      get capacity() {
+        return this.maxSize;
+      }
       get(key) {
         if (!this.cache.has(key)) return void 0;
         const value = this.cache.get(key);
@@ -5789,6 +5888,11 @@ var init_object_validator = __esm({
 });
 
 // src/validators/string-validator.ts
+function configurePatternCache(size) {
+  if (size > 0 && size !== PATTERN_CACHE.capacity) {
+    PATTERN_CACHE = new LRUCache(size);
+  }
+}
 function generateStringValidation(schema, useDescribe) {
   let validation = FORMAT_MAP[schema.format || ""] || "z.string()";
   if (schema.minLength !== void 0) {
@@ -6434,6 +6538,7 @@ var init_operation_filters = __esm({
 // src/openapi-generator.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, normalize } from "path";
+import { minimatch as minimatch2 } from "minimatch";
 import { parse } from "yaml";
 var OpenApiGenerator;
 var init_openapi_generator = __esm({
@@ -6446,18 +6551,16 @@ var init_openapi_generator = __esm({
     init_property_generator();
     init_name_utils();
     init_operation_filters();
+    init_string_validator();
     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;
+        var _a, _b, _c, _d, _e;
         if (!options.input) {
           throw new ConfigurationError("Input path is required", { providedOptions: options });
         }
@@ -6466,17 +6569,21 @@ var init_openapi_generator = __esm({
           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
+          operationFilters: options.operationFilters,
+          ignoreHeaders: options.ignoreHeaders,
+          cacheSize: (_d = options.cacheSize) != null ? _d : 1e3,
+          batchSize: (_e = options.batchSize) != null ? _e : 10
         };
+        if (this.options.cacheSize) {
+          configurePatternCache(this.options.cacheSize);
+        }
         try {
           const fs = __require("fs");
           if (!fs.existsSync(this.options.input)) {
@@ -6532,7 +6639,6 @@ var init_openapi_generator = __esm({
         this.requestOptions = this.resolveOptionsForContext("request");
         this.responseOptions = this.resolveOptionsForContext("response");
         this.analyzeSchemaUsage();
-        this.determineSchemaTypeModes();
         this.propertyGenerator = new PropertyGenerator({
           spec: this.spec,
           schemaDependencies: this.schemaDependencies,
@@ -6540,8 +6646,6 @@ var init_openapi_generator = __esm({
           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
@@ -6557,25 +6661,6 @@ var init_openapi_generator = __esm({
         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);
         }
@@ -6592,22 +6677,11 @@ var init_openapi_generator = __esm({
           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`;
@@ -6645,25 +6719,19 @@ var init_openapi_generator = __esm({
         const normalizedOutput = normalize(this.options.output);
         this.ensureDirectoryExists(normalizedOutput);
         writeFileSync(normalizedOutput, output);
+        console.log(`  \u2713 Generated ${normalizedOutput}`);
       }
       /**
        * 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
         };
       }
       /**
@@ -6854,28 +6922,6 @@ var init_openapi_generator = __esm({
           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
        */
@@ -6951,80 +6997,54 @@ var init_openapi_generator = __esm({
         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);
+        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
           }
-          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 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
@@ -7110,6 +7130,24 @@ ${propsCode}
           }
         }
       }
+      /**
+       * Check if a header should be ignored based on filter patterns
+       * @internal
+       */
+      shouldIgnoreHeader(headerName) {
+        const ignorePatterns = this.options.ignoreHeaders;
+        if (!ignorePatterns || ignorePatterns.length === 0) {
+          return false;
+        }
+        if (ignorePatterns.includes("*")) {
+          return true;
+        }
+        const headerLower = headerName.toLowerCase();
+        return ignorePatterns.some((pattern) => {
+          const patternLower = pattern.toLowerCase();
+          return minimatch2(headerLower, patternLower);
+        });
+      }
       /**
        * Generate header parameter schemas for each operation
        * Header parameters are always string type (HTTP header semantics)
@@ -7132,7 +7170,7 @@ ${propsCode}
               continue;
             }
             const headerParams = operation.parameters.filter(
-              (param) => param && typeof param === "object" && param.in === "header"
+              (param) => param && typeof param === "object" && param.in === "header" && !this.shouldIgnoreHeader(param.name)
             );
             if (headerParams.length === 0) {
               continue;
@@ -7230,151 +7268,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
@@ -7386,9 +7284,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);
         }
@@ -7413,7 +7308,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);
               }
             }
@@ -7424,7 +7319,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);
         }
@@ -7442,7 +7337,6 @@ ${props.join("\n")}
       generateStats() {
         const stats = {
           totalSchemas: this.schemas.size,
-          enums: this.enums.size,
           withCircularRefs: 0,
           withDiscriminators: 0,
           withConstraints: 0
@@ -7457,7 +7351,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}`
@@ -7476,120 +7369,108 @@ ${props.join("\n")}
   }
 });
 
-// src/batch-executor.ts
-async function processSpec(spec, index, total) {
-  console.log(`Processing [${index + 1}/${total}] ${spec.input}...`);
-  try {
-    const generator = new OpenApiGenerator(spec);
-    generator.generate();
-    console.log(`\u2713 Successfully generated ${spec.output}`);
-    return {
-      spec,
-      success: true
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`\u2717 Failed to generate ${spec.output}: ${errorMessage}`);
-    return {
-      spec,
-      success: false,
-      error: errorMessage
-    };
-  }
-}
-async function executeParallel(specs) {
-  console.log(`
-Executing ${specs.length} spec(s) in parallel...
-`);
-  const promises = specs.map((spec, index) => processSpec(spec, index, specs.length));
-  const results = await Promise.allSettled(promises);
-  return results.map((result, index) => {
-    if (result.status === "fulfilled") {
-      return result.value;
-    }
-    return {
-      spec: specs[index],
-      success: false,
-      error: result.reason instanceof Error ? result.reason.message : String(result.reason)
-    };
-  });
-}
-async function executeSequential(specs) {
-  console.log(`
-Executing ${specs.length} spec(s) sequentially...
-`);
-  const results = [];
-  for (let i = 0; i < specs.length; i++) {
-    const result = await processSpec(specs[i], i, specs.length);
-    results.push(result);
+// src/utils/config-schemas.ts
+import { z } from "zod";
+var RequestResponseOptionsSchema, OperationFiltersSchema;
+var init_config_schemas = __esm({
+  "src/utils/config-schemas.ts"() {
+    "use strict";
+    init_esm_shims();
+    RequestResponseOptionsSchema = z.strictObject({
+      mode: z.enum(["strict", "normal", "loose"]).optional(),
+      useDescribe: z.boolean().optional(),
+      includeDescriptions: z.boolean().optional()
+    });
+    OperationFiltersSchema = z.strictObject({
+      includeTags: z.array(z.string()).optional(),
+      excludeTags: z.array(z.string()).optional(),
+      includePaths: z.array(z.string()).optional(),
+      excludePaths: z.array(z.string()).optional(),
+      includeMethods: z.array(z.string()).optional(),
+      excludeMethods: z.array(z.string()).optional(),
+      includeOperationIds: z.array(z.string()).optional(),
+      excludeOperationIds: z.array(z.string()).optional(),
+      excludeDeprecated: z.boolean().optional()
+    });
   }
-  return results;
-}
-function printSummary(summary) {
-  console.log(`
-${"=".repeat(50)}`);
-  console.log("Batch Execution Summary");
-  console.log("=".repeat(50));
-  console.log(`Total specs: ${summary.total}`);
-  console.log(`Successful: ${summary.successful}`);
-  console.log(`Failed: ${summary.failed}`);
-  if (summary.failed > 0) {
-    console.log("\nFailed specs:");
-    for (const result of summary.results) {
-      if (!result.success) {
-        console.error(`  \u2717 ${result.spec.input}`);
-        console.error(`    Error: ${result.error}`);
-      }
-    }
+});
+
+// src/utils/config-validation.ts
+function formatConfigValidationError(error, filepath, configPath, additionalNotes) {
+  var _a;
+  const formattedErrors = ((_a = error.issues) == null ? void 0 : _a.map((err) => {
+    const path2 = err.path.length > 0 ? err.path.join(".") : "root";
+    return `  - ${path2}: ${err.message}`;
+  }).join("\n")) || "Unknown validation error";
+  const configSource = filepath || configPath || "config file";
+  const lines = [
+    `Invalid configuration file at: ${configSource}`,
+    "",
+    "Validation errors:",
+    formattedErrors,
+    "",
+    "Please check your configuration file and ensure:",
+    "  - All required fields are present (specs array with input/output)",
+    "  - Field names are spelled correctly (no typos)",
+    "  - Values match the expected types (e.g., mode: 'strict' | 'normal' | 'loose')",
+    "  - No unknown/extra properties are included"
+  ];
+  if (additionalNotes && additionalNotes.length > 0) {
+    lines.push(...additionalNotes.map((note) => `  - ${note}`));
   }
-  console.log(`${"=".repeat(50)}
-`);
+  return lines.join("\n");
 }
-async function executeBatch(specs, executionMode = "parallel") {
-  if (specs.length === 0) {
-    throw new ConfigurationError("No specs provided for batch execution", { specsCount: 0, executionMode });
+var init_config_validation = __esm({
+  "src/utils/config-validation.ts"() {
+    "use strict";
+    init_esm_shims();
   }
-  let results = [];
-  try {
-    results = executionMode === "parallel" ? await executeParallel(specs) : await executeSequential(specs);
-    const summary = {
-      total: results.length,
-      successful: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      results
-    };
-    printSummary(summary);
-    return summary;
-  } finally {
-    if (results.length > 10) {
-      for (const result of results) {
-        if (result.spec) {
-          result.spec = null;
-        }
-      }
-      if (global.gc) {
-        global.gc();
-      }
+});
+
+// src/utils/typescript-loader.ts
+function createTypeScriptLoader() {
+  return async (filepath) => {
+    try {
+      const esbuild = await import("esbuild");
+      const fs = await import("fs");
+      const path2 = await import("path");
+      const tsCode = fs.readFileSync(filepath, "utf-8");
+      const result = await esbuild.build({
+        stdin: {
+          contents: tsCode,
+          loader: "ts",
+          resolveDir: path2.dirname(filepath),
+          sourcefile: filepath
+        },
+        format: "cjs",
+        platform: "node",
+        target: "node18",
+        bundle: false,
+        write: false
+      });
+      const jsCode = result.outputFiles[0].text;
+      const module = { exports: {} };
+      const func = new Function("exports", "module", "require", "__filename", "__dirname", jsCode);
+      func(module.exports, module, __require, filepath, path2.dirname(filepath));
+      return module.exports.default || module.exports;
+    } catch (error) {
+      throw new Error(
+        `Failed to load TypeScript config from ${filepath}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-  }
-}
-function getBatchExitCode(summary) {
-  return summary.failed > 0 ? 1 : 0;
+  };
 }
-var init_batch_executor = __esm({
-  "src/batch-executor.ts"() {
+var init_typescript_loader = __esm({
+  "src/utils/typescript-loader.ts"() {
     "use strict";
     init_esm_shims();
-    init_errors();
-    init_openapi_generator();
   }
 });
 
 // src/utils/config-loader.ts
 import { cosmiconfig } from "cosmiconfig";
-import { z } from "zod";
+import { z as z2 } from "zod";
 async function loadConfig(configPath) {
-  var _a;
   const explorer = cosmiconfig("openapi-to-zod", {
     searchPlaces: ["openapi-to-zod.config.ts", "openapi-to-zod.config.json", "package.json"],
     loaders: {
@@ -7611,24 +7492,8 @@ async function loadConfig(configPath) {
     const validatedConfig = ConfigFileSchema.parse(result.config);
     return validatedConfig;
   } catch (error) {
-    if (error instanceof z.ZodError) {
-      const formattedErrors = ((_a = error.issues) == null ? void 0 : _a.map((err) => {
-        const path2 = err.path.length > 0 ? err.path.join(".") : "root";
-        return `  - ${path2}: ${err.message}`;
-      }).join("\n")) || "Unknown validation error";
-      const configSource = result.filepath || configPath || "config file";
-      const errorMessage = [
-        `Invalid configuration file at: ${configSource}`,
-        "",
-        "Validation errors:",
-        formattedErrors,
-        "",
-        "Please check your configuration file and ensure:",
-        "  - All required fields are present (specs array with input/output)",
-        "  - Field names are spelled correctly (no typos)",
-        "  - Values match the expected types (e.g., mode: 'strict' | 'normal' | 'loose')",
-        "  - No unknown/extra properties are included"
-      ].join("\n");
+    if (error instanceof z2.ZodError) {
+      const errorMessage = formatConfigValidationError(error, result.filepath, configPath);
       throw new Error(errorMessage);
     }
     throw error;
@@ -7644,7 +7509,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,
@@ -7656,99 +7520,53 @@ function mergeConfigWithDefaults(config) {
     return merged;
   });
 }
-var TypeModeSchema, NativeEnumTypeSchema, RequestResponseOptionsSchema, OperationFiltersSchema, OpenApiGeneratorOptionsSchema, ConfigFileSchema, createTypeScriptLoader;
+var OpenApiGeneratorOptionsSchema, ConfigFileSchema;
 var init_config_loader = __esm({
   "src/utils/config-loader.ts"() {
     "use strict";
     init_esm_shims();
-    TypeModeSchema = z.enum(["inferred", "native"]);
-    NativeEnumTypeSchema = z.enum(["union", "enum"]);
-    RequestResponseOptionsSchema = z.strictObject({
-      mode: z.enum(["strict", "normal", "loose"]).optional(),
-      enumType: z.enum(["zod", "typescript"]).optional(),
-      useDescribe: z.boolean().optional(),
-      includeDescriptions: z.boolean().optional(),
-      typeMode: TypeModeSchema.optional(),
-      nativeEnumType: NativeEnumTypeSchema.optional()
-    });
-    OperationFiltersSchema = z.strictObject({
-      includeTags: z.array(z.string()).optional(),
-      excludeTags: z.array(z.string()).optional(),
-      includePaths: z.array(z.string()).optional(),
-      excludePaths: z.array(z.string()).optional(),
-      includeMethods: z.array(z.string()).optional(),
-      excludeMethods: z.array(z.string()).optional(),
-      includeOperationIds: z.array(z.string()).optional(),
-      excludeOperationIds: z.array(z.string()).optional(),
-      excludeDeprecated: z.boolean().optional()
-    });
-    OpenApiGeneratorOptionsSchema = z.strictObject({
-      mode: z.enum(["strict", "normal", "loose"]).optional(),
-      input: z.string(),
-      output: z.string(),
-      includeDescriptions: z.boolean().optional(),
-      enumType: z.enum(["zod", "typescript"]).optional(),
-      useDescribe: z.boolean().optional(),
-      schemaType: z.enum(["all", "request", "response"]).optional(),
-      prefix: z.string().optional(),
-      suffix: z.string().optional(),
-      showStats: z.boolean().optional(),
-      nativeEnumType: NativeEnumTypeSchema.optional(),
+    init_config_schemas();
+    init_config_validation();
+    init_typescript_loader();
+    OpenApiGeneratorOptionsSchema = z2.strictObject({
+      mode: z2.enum(["strict", "normal", "loose"]).optional(),
+      input: z2.string(),
+      output: z2.string(),
+      includeDescriptions: z2.boolean().optional(),
+      useDescribe: z2.boolean().optional(),
+      schemaType: z2.enum(["all", "request", "response"]).optional(),
+      prefix: z2.string().optional(),
+      suffix: z2.string().optional(),
+      showStats: z2.boolean().optional(),
       request: RequestResponseOptionsSchema.optional(),
       response: RequestResponseOptionsSchema.optional(),
-      name: z.string().optional(),
-      operationFilters: OperationFiltersSchema.optional()
+      name: z2.string().optional(),
+      operationFilters: OperationFiltersSchema.optional(),
+      cacheSize: z2.number().positive().optional(),
+      batchSize: z2.number().positive().optional()
     });
-    ConfigFileSchema = z.strictObject({
-      defaults: z.strictObject({
-        mode: z.enum(["strict", "normal", "loose"]).optional(),
-        includeDescriptions: z.boolean().optional(),
-        enumType: z.enum(["zod", "typescript"]).optional(),
-        useDescribe: z.boolean().optional(),
-        schemaType: z.enum(["all", "request", "response"]).optional(),
-        prefix: z.string().optional(),
-        suffix: z.string().optional(),
-        showStats: z.boolean().optional(),
-        nativeEnumType: NativeEnumTypeSchema.optional(),
+    ConfigFileSchema = z2.strictObject({
+      defaults: z2.strictObject({
+        mode: z2.enum(["strict", "normal", "loose"]).optional(),
+        includeDescriptions: z2.boolean().optional(),
+        useDescribe: z2.boolean().optional(),
+        schemaType: z2.enum(["all", "request", "response"]).optional(),
+        prefix: z2.string().optional(),
+        suffix: z2.string().optional(),
+        showStats: z2.boolean().optional(),
         request: RequestResponseOptionsSchema.optional(),
         response: RequestResponseOptionsSchema.optional(),
-        operationFilters: OperationFiltersSchema.optional()
+        operationFilters: OperationFiltersSchema.optional(),
+        cacheSize: z2.number().positive().optional(),
+        batchSize: z2.number().positive().optional()
       }).optional(),
-      specs: z.array(OpenApiGeneratorOptionsSchema).min(1, "At least one spec is required"),
-      executionMode: z.enum(["parallel", "sequential"]).optional()
+      specs: z2.array(OpenApiGeneratorOptionsSchema).min(1, {
+        message: "Configuration must include at least one specification. Each specification should have 'input' and 'output' paths."
+      }).refine((specs) => specs.every((spec) => spec.input && spec.output), {
+        message: "Each specification must have both 'input' and 'output' paths defined"
+      }),
+      executionMode: z2.enum(["parallel", "sequential"]).optional()
     });
-    createTypeScriptLoader = () => {
-      return async (filepath) => {
-        try {
-          const esbuild = await import("esbuild");
-          const fs = await import("fs");
-          const path2 = await import("path");
-          const tsCode = fs.readFileSync(filepath, "utf-8");
-          const result = await esbuild.build({
-            stdin: {
-              contents: tsCode,
-              loader: "ts",
-              resolveDir: path2.dirname(filepath),
-              sourcefile: filepath
-            },
-            format: "cjs",
-            platform: "node",
-            target: "node18",
-            bundle: false,
-            write: false
-          });
-          const jsCode = result.outputFiles[0].text;
-          const module = { exports: {} };
-          const func = new Function("exports", "module", "require", "__filename", "__dirname", jsCode);
-          func(module.exports, module, __require, filepath, path2.dirname(filepath));
-          return module.exports.default || module.exports;
-        } catch (error) {
-          throw new Error(
-            `Failed to load TypeScript config from ${filepath}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      };
-    };
   }
 });
 
@@ -7762,6 +7580,7 @@ var require_cli = __commonJS({
     var import_prompts = __toESM(require_prompts3());
     init_batch_executor();
     init_errors();
+    init_openapi_generator();
     init_config_loader();
     var program = new Command();
     program.name("openapi-to-zod").description("Generate Zod v4 schemas from OpenAPI specifications").version("1.0.0").option("-c, --config <path>", "Path to config file (openapi-to-zod.config.{ts,json})").addHelpText(
@@ -7769,17 +7588,13 @@ var require_cli = __commonJS({
       `
 Examples:
   # Create a new config file
-  $ openapi-to-zod --init
+  $ openapi-to-zod init
 
   # Generate with auto-discovered config
   $ openapi-to-zod
 
   # Generate with custom config path
   $ openapi-to-zod --config custom.config.ts
-
-Breaking Changes (v2.0):
-  CLI options removed. Use configuration file instead.
-  Run 'openapi-to-zod --init' to create a config file.
 `
     ).action(async (options) => {
       try {
@@ -7836,17 +7651,19 @@ Breaking Changes (v2.0):
       return { files, totalCount };
     }
     async function executeConfigMode(options) {
+      var _a, _b;
       let config;
       try {
         config = await loadConfig(options.config);
       } catch {
-        throw new CliOptionsError("No config file found. Run 'openapi-to-zod --init' to create one.", {
+        throw new CliOptionsError("No config file found. Run 'openapi-to-zod init' to create one.", {
           configPath: options.config
         });
       }
       const specs = mergeConfigWithDefaults(config);
       const executionMode = config.executionMode || "parallel";
-      const summary = await executeBatch(specs, executionMode);
+      const batchSize = (_b = (_a = specs[0]) == null ? void 0 : _a.batchSize) != null ? _b : 10;
+      const summary = await executeBatch(specs, executionMode, (spec) => new OpenApiGenerator(spec), batchSize);
       const exitCode = getBatchExitCode(summary);
       if (exitCode !== 0) {
         process.exit(exitCode);
@@ -7948,7 +7765,7 @@ Breaking Changes (v2.0):
         {
           type: "confirm",
           name: "includeDefaults",
-          message: "Include commonly-used defaults? (mode: strict, includeDescriptions: true, showStats: false)",
+          message: "Include commonly-used recommended defaults?",
           initial: true
         }
       ]);
@@ -7969,7 +7786,9 @@ export default defineConfig({
   defaults: {
     mode: 'strict',
     includeDescriptions: true,
-    showStats: false,
+	useDescribe: false,
+    showStats: true,
+	schemaType: 'all',
   },
   specs: [
     {