@cerios/openapi-to-zod 0.6.0 → 1.1.0

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+import { O as OpenApiGeneratorOptions } from './types-B7ePTDjr.js';
+export { C as CommonSchemaOptions, a as ConfigFile, E as ExecutionMode, b as OpenAPISchema, c as OpenAPISpec, d as OperationFilters, R as RequestOptions, e as ResponseOptions, f as defineConfig } from './types-B7ePTDjr.js';
+
 /**
  * Custom error classes for better error handling and debugging
  */
@@ -50,298 +53,6 @@ declare class CliOptionsError extends GeneratorError {
     constructor(message: string, context?: Record<string, unknown>);
 }
 
-/**
- * Common options shared by both request and response contexts
- */
-interface CommonSchemaOptions {
-    /**
-     * Object validation mode
-     * - 'strict': Uses z.strictObject() - no additional properties allowed
-     * - 'normal': Uses z.object() - additional properties allowed
-     * - 'loose': Uses z.looseObject() - explicitly allows additional properties
-     */
-    mode?: "strict" | "normal" | "loose";
-    /**
-     * Whether to add .describe() calls for better error messages
-     * @default false
-     */
-    useDescribe?: boolean;
-    /**
-     * Whether to include descriptions as JSDoc comments
-     */
-    includeDescriptions?: boolean;
-}
-/**
- * Request-specific options that can override root-level options
- */
-interface RequestOptions extends CommonSchemaOptions {
-}
-/**
- * Response-specific options that can override root-level options
- */
-interface ResponseOptions extends CommonSchemaOptions {
-}
-interface OpenApiGeneratorOptions {
-    /**
-     * Object validation mode
-     * - 'strict': Uses z.strictObject() - no additional properties allowed
-     * - 'normal': Uses z.object() - additional properties allowed
-     * - 'loose': Uses z.looseObject() - explicitly allows additional properties
-     */
-    mode?: "strict" | "normal" | "loose";
-    /**
-     * Input OpenAPI YAML file path
-     */
-    input: string;
-    /**
-     * Output TypeScript file path
-     * Optional when using string generation methods (generateString)
-     * Required when calling generate() to write to a file
-     */
-    output?: string;
-    /**
-     * Whether to include descriptions as JSDoc comments
-     */
-    includeDescriptions?: boolean;
-    /**
-     * Whether to add .describe() calls for better error messages
-     * @default false
-     */
-    useDescribe?: boolean;
-    /**
-     * Schema filtering mode
-     * - 'all': Generate all schemas (default)
-     * - 'request': Only include schemas suitable for requests (excludes readOnly)
-     * - 'response': Only include schemas suitable for responses (excludes writeOnly)
-     */
-    schemaType?: "all" | "request" | "response";
-    /**
-     * Prefix to add to all generated schema names
-     * @example "api" -> "apiUserSchema"
-     */
-    prefix?: string;
-    /**
-     * Suffix to add before "Schema" in generated names
-     * @example "dto" -> "userDtoSchema"
-     */
-    suffix?: string;
-    /**
-     * Whether to include generation statistics in output file
-     * @default true
-     */
-    showStats?: boolean;
-    /**
-     * Request-specific options that override root-level options
-     * Applied when schemas are used in request contexts
-     */
-    request?: RequestOptions;
-    /**
-     * Response-specific options that override root-level options
-     * Applied when schemas are used in response contexts
-     */
-    response?: ResponseOptions;
-    /**
-     * Filter which operations to include/exclude from generation
-     * Useful for generating separate schemas for different API subsets
-     *
-     * Filtering logic:
-     * 1. If no filters specified, all operations are included
-     * 2. Empty arrays are treated as "no constraint" (not as "exclude all")
-     * 3. Include filters are applied first (allowlist)
-     * 4. Exclude filters are applied second (blocklist)
-     * 5. Exclude rules always win over include rules
-     *
-     * Supports glob patterns for paths and operationIds (e.g., "/api/v1/**", "get*")
-     *
-     * @example
-     * // Only generate schemas for user-related endpoints
-     * operationFilters: {
-     *   includeTags: ["users"]
-     * }
-     *
-     * @example
-     * // Generate only GET endpoints, excluding deprecated ones
-     * operationFilters: {
-     *   includeMethods: ["get"],
-     *   excludeDeprecated: true
-     * }
-     *
-     * @example
-     * // Generate only v1 API endpoints
-     * operationFilters: {
-     *   includePaths: ["/api/v1/**"]
-     * }
-     */
-    operationFilters?: OperationFilters;
-}
-/**
- * Operation filtering options
- * Controls which operations from the OpenAPI spec are included in generation
- */
-interface OperationFilters {
-    /**
-     * Include only operations with these tags
-     * If specified, only operations with at least one matching tag are included
-     * Empty array = no constraint
-     */
-    includeTags?: string[];
-    /**
-     * Exclude operations with these tags
-     * Operations with any matching tag are excluded
-     * Empty array = no constraint
-     */
-    excludeTags?: string[];
-    /**
-     * Include only operations matching these path patterns
-     * Supports glob patterns (e.g., "/users/**", "/api/v1/*")
-     * Empty array = no constraint
-     */
-    includePaths?: string[];
-    /**
-     * Exclude operations matching these path patterns
-     * Supports glob patterns (e.g., "/internal/**", "/admin/*")
-     * Empty array = no constraint
-     */
-    excludePaths?: string[];
-    /**
-     * Include only these HTTP methods
-     * Valid values: "get", "post", "put", "patch", "delete", "head", "options"
-     * Empty array = no constraint
-     */
-    includeMethods?: string[];
-    /**
-     * Exclude these HTTP methods
-     * Valid values: "get", "post", "put", "patch", "delete", "head", "options"
-     * Empty array = no constraint
-     */
-    excludeMethods?: string[];
-    /**
-     * Include only operations matching these operationId patterns
-     * Supports glob patterns (e.g., "getUser*", "*Admin")
-     * Empty array = no constraint
-     */
-    includeOperationIds?: string[];
-    /**
-     * Exclude operations matching these operationId patterns
-     * Supports glob patterns (e.g., "deleteUser*", "*Internal")
-     * Empty array = no constraint
-     */
-    excludeOperationIds?: string[];
-    /**
-     * Whether to exclude deprecated operations
-     * @default false
-     */
-    excludeDeprecated?: boolean;
-}
-interface OpenAPISchema {
-    type?: string | string[];
-    format?: string;
-    enum?: (string | number)[];
-    const?: string | number | boolean | null;
-    properties?: Record<string, OpenAPISchema>;
-    required?: string[];
-    items?: OpenAPISchema;
-    prefixItems?: OpenAPISchema[];
-    allOf?: OpenAPISchema[];
-    oneOf?: OpenAPISchema[];
-    anyOf?: OpenAPISchema[];
-    $ref?: string;
-    nullable?: boolean;
-    minLength?: number;
-    maxLength?: number;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: boolean | number;
-    exclusiveMaximum?: boolean | number;
-    multipleOf?: number;
-    pattern?: string;
-    description?: string;
-    title?: string;
-    example?: any;
-    examples?: any[];
-    additionalProperties?: boolean | OpenAPISchema;
-    minProperties?: number;
-    maxProperties?: number;
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-    contains?: OpenAPISchema;
-    minContains?: number;
-    maxContains?: number;
-    discriminator?: {
-        propertyName: string;
-        mapping?: Record<string, string>;
-    };
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    deprecated?: boolean;
-    dependentRequired?: Record<string, string[]>;
-    dependencies?: Record<string, string[] | OpenAPISchema>;
-    patternProperties?: Record<string, OpenAPISchema>;
-    propertyNames?: OpenAPISchema;
-    contentMediaType?: string;
-    contentEncoding?: string;
-    not?: OpenAPISchema;
-    if?: OpenAPISchema;
-    then?: OpenAPISchema;
-    else?: OpenAPISchema;
-    unevaluatedProperties?: boolean | OpenAPISchema;
-    unevaluatedItems?: boolean | OpenAPISchema;
-}
-interface OpenAPISpec {
-    components?: {
-        schemas?: Record<string, OpenAPISchema>;
-    };
-    paths?: Record<string, any>;
-}
-/**
- * Execution mode for batch processing
- * - 'parallel': Process all specs concurrently (default, faster)
- * - 'sequential': Process specs one at a time (safer for resource constraints)
- */
-type ExecutionMode = "parallel" | "sequential";
-/**
- * Root configuration file structure
- */
-interface ConfigFile {
-    /**
-     * Global default options applied to all specs
-     * Can be overridden by individual spec configurations
-     */
-    defaults?: Partial<Omit<OpenApiGeneratorOptions, "input" | "output">>;
-    /**
-     * Array of OpenAPI specifications to process
-     * Each spec must have input and output paths
-     */
-    specs: OpenApiGeneratorOptions[];
-    /**
-     * Execution mode for batch processing
-     * @default "parallel"
-     */
-    executionMode?: ExecutionMode;
-}
-/**
- * Helper function for type-safe config file creation
- * Provides IDE autocomplete and type checking for config files
- *
- * @example
- * ```typescript
- * import { defineConfig } from '@cerios/openapi-to-zod';
- *
- * export default defineConfig({
- *   defaults: {
- *     mode: 'strict',
- *     includeDescriptions: true
- *   },
- *   specs: [
- *     { input: 'api-v1.yaml', output: 'schemas/v1.ts' },
- *     { input: 'api-v2.yaml', output: 'schemas/v2.ts', mode: 'normal' }
- *   ]
- * });
- * ```
- */
-declare function defineConfig(config: ConfigFile): ConfigFile;
-
 declare class OpenApiGenerator {
     private schemas;
     private types;
@@ -414,6 +125,11 @@ declare class OpenApiGenerator {
      * Generate query parameter schemas for each operation
      */
     private generateQueryParameterSchemas;
+    /**
+     * Check if a header should be ignored based on filter patterns
+     * @internal
+     */
+    private shouldIgnoreHeader;
     /**
      * Generate header parameter schemas for each operation
      * Header parameters are always string type (HTTP header semantics)
@@ -434,55 +150,4 @@ declare class OpenApiGenerator {
     private generateStats;
 }
 
-/**
- * Filter statistics to track which operations were included/excluded
- */
-interface FilterStatistics {
-    totalOperations: number;
-    includedOperations: number;
-    filteredByTags: number;
-    filteredByPaths: number;
-    filteredByMethods: number;
-    filteredByOperationIds: number;
-    filteredByDeprecated: number;
-}
-/**
- * Create a new filter statistics object with all counters initialized to zero
- */
-declare function createFilterStatistics(): FilterStatistics;
-/**
- * Determine if an operation should be included based on filter criteria
- *
- * Filter logic:
- * 1. If no filters specified, include all operations
- * 2. Empty arrays are treated as "no constraint" (not as "exclude all")
- * 3. Include filters are applied first (allowlist)
- * 4. Exclude filters are applied second (blocklist)
- * 5. Exclude rules always win over include rules
- *
- * @param operation - The OpenAPI operation object
- * @param path - The operation path (e.g., "/users/{id}")
- * @param method - The HTTP method (e.g., "get", "post")
- * @param filters - Optional filter configuration
- * @param stats - Optional statistics object to track filtering reasons
- * @returns true if the operation should be included, false otherwise
- */
-declare function shouldIncludeOperation(operation: any, path: string, method: string, filters?: OperationFilters, stats?: FilterStatistics): boolean;
-/**
- * Validate filter statistics and emit warnings for filters that matched nothing
- * Helps users debug filter configurations that might be too restrictive or contain typos
- *
- * @param stats - Filter statistics object
- * @param filters - The filter configuration to validate
- */
-declare function validateFilters(stats: FilterStatistics, filters?: OperationFilters): void;
-/**
- * Format filter statistics for display in generated output
- * Returns a formatted string suitable for inclusion in comments
- *
- * @param stats - Filter statistics object
- * @returns Formatted statistics string
- */
-declare function formatFilterStatistics(stats: FilterStatistics): string;
-
-export { CircularReferenceError, CliOptionsError, type CommonSchemaOptions, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, type FilterStatistics, GeneratorError, type OpenAPISchema, type OpenAPISpec, OpenApiGenerator, type OpenApiGeneratorOptions, type OperationFilters, type RequestOptions, type ResponseOptions, SchemaGenerationError, SpecValidationError, createFilterStatistics, defineConfig, formatFilterStatistics, shouldIncludeOperation, validateFilters };
+export { CircularReferenceError, CliOptionsError, ConfigValidationError, FileOperationError, GeneratorError, OpenApiGenerator, OpenApiGeneratorOptions, SchemaGenerationError, SpecValidationError };

package/dist/index.js

@@ -28,11 +28,7 @@ __export(src_exports, {
   OpenApiGenerator: () => OpenApiGenerator,
   SchemaGenerationError: () => SchemaGenerationError,
   SpecValidationError: () => SpecValidationError,
-  createFilterStatistics: () => createFilterStatistics,
-  defineConfig: () => defineConfig,
-  formatFilterStatistics: () => formatFilterStatistics,
-  shouldIncludeOperation: () => shouldIncludeOperation,
-  validateFilters: () => validateFilters
+  defineConfig: () => defineConfig
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -98,11 +94,24 @@ var ConfigurationError = class extends GeneratorError {
 // src/openapi-generator.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
+var import_minimatch2 = require("minimatch");
 var import_yaml = require("yaml");
 
 // src/utils/name-utils.ts
+function sanitizeIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9._\-\s]+/g, "_");
+}
 function toCamelCase(str, options) {
-  let name = str.charAt(0).toLowerCase() + str.slice(1);
+  const sanitized = sanitizeIdentifier(str);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let name;
+  if (words.length === 0) {
+    name = str.charAt(0).toLowerCase() + str.slice(1);
+  } else if (words.length === 1) {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  } else {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
   if (options == null ? void 0 : options.prefix) {
     const prefix = options.prefix.toLowerCase();
     name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
@@ -115,12 +124,23 @@ function toCamelCase(str, options) {
 }
 function toPascalCase(str) {
   const stringValue = String(str);
-  let result = stringValue.replace(/[^a-zA-Z0-9_]+/g, "_").split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  const isAlreadyValidCase = /^[a-zA-Z][a-zA-Z0-9]*$/.test(stringValue);
+  if (isAlreadyValidCase) {
+    return stringValue.charAt(0).toUpperCase() + stringValue.slice(1);
+  }
+  const sanitized = sanitizeIdentifier(stringValue);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let result;
+  if (words.length === 0) {
+    result = "Value";
+  } else {
+    result = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
   if (/^\d/.test(result)) {
     result = `N${result}`;
   }
   if (!result || /^_+$/.test(result)) {
-    result = "Value";
+    return "Value";
   }
   return result;
 }
@@ -132,9 +152,10 @@ function resolveRef(ref) {
 // src/generators/enum-generator.ts
 function generateEnum(name, values, options) {
   const schemaName = `${toCamelCase(name, options)}Schema`;
+  const typeName = toPascalCase(name);
   const enumValues = values.map((v) => `"${v}"`).join(", ");
   const schemaCode = `export const ${schemaName} = z.enum([${enumValues}]);`;
-  const typeCode = `export type ${name} = z.infer<typeof ${schemaName}>;`;
+  const typeCode = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
   return { schemaCode, typeCode };
 }
 
@@ -234,6 +255,9 @@ var LRUCache = class {
     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);
@@ -264,6 +288,76 @@ var LRUCache = class {
   }
 };
 
+// src/utils/pattern-utils.ts
+function isRegexPattern(pattern) {
+  if (pattern.startsWith("^") || pattern.endsWith("$")) {
+    return true;
+  }
+  if (/\\[dDwWsS]/.test(pattern)) {
+    return true;
+  }
+  if (/\.\*|\.\+/.test(pattern)) {
+    return true;
+  }
+  if (/[[\]()]/.test(pattern)) {
+    return true;
+  }
+  if (/[^/][+?*]\{/.test(pattern)) {
+    return true;
+  }
+  return false;
+}
+function patternToRegex(pattern) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  if (isRegexPattern(pattern)) {
+    try {
+      return new RegExp(pattern);
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Invalid regex pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  return null;
+}
+function stripPrefix(input, pattern, ensureLeadingChar) {
+  if (!pattern) {
+    return input;
+  }
+  const regex = patternToRegex(pattern);
+  if (regex) {
+    const match = input.match(regex);
+    if (match && match.index === 0) {
+      const stripped = input.substring(match[0].length);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped;
+    }
+  } else {
+    const stringPattern = pattern;
+    if (input.startsWith(stringPattern)) {
+      const stripped = input.substring(stringPattern.length);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped;
+    }
+  }
+  return input;
+}
+
 // src/validators/array-validator.ts
 function generateArrayValidation(schema, context) {
   var _a;
@@ -783,6 +877,11 @@ ${properties.join(",\n")}
 
 // src/validators/string-validator.ts
 var PATTERN_CACHE = new LRUCache(1e3);
+function configurePatternCache(size) {
+  if (size > 0 && size !== PATTERN_CACHE.capacity) {
+    PATTERN_CACHE = new LRUCache(size);
+  }
+}
 var FORMAT_MAP = {
   uuid: "z.uuid()",
   email: "z.email()",
@@ -1115,8 +1214,9 @@ var _PropertyGenerator = class _PropertyGenerator {
         }
         (_a = this.context.schemaDependencies.get(currentSchema)) == null ? void 0 : _a.add(refName);
       }
-      const schemaName = `${toCamelCase(resolvedRefName, this.context.namingOptions)}Schema`;
-      if (currentSchema && this.isCircularThroughAlias(currentSchema, refName)) {
+      const strippedRefName = stripPrefix(resolvedRefName, this.context.stripSchemaPrefix);
+      const schemaName = `${toCamelCase(strippedRefName, this.context.namingOptions)}Schema`;
+      if (currentSchema && (refName === currentSchema || this.isCircularThroughAlias(currentSchema, refName))) {
         const lazySchema = `z.lazy((): z.ZodTypeAny => ${schemaName})`;
         return wrapNullable(lazySchema, nullable);
       }
@@ -1403,7 +1503,7 @@ var OpenApiGenerator = class {
     this.schemaUsageMap = /* @__PURE__ */ new Map();
     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 });
     }
@@ -1416,11 +1516,18 @@ var OpenApiGenerator = class {
       schemaType: options.schemaType || "all",
       prefix: options.prefix,
       suffix: options.suffix,
+      stripSchemaPrefix: options.stripSchemaPrefix,
       showStats: (_c = options.showStats) != null ? _c : true,
       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)) {
@@ -1486,7 +1593,8 @@ var OpenApiGenerator = class {
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
-      }
+      },
+      stripSchemaPrefix: this.options.stripSchemaPrefix
     });
   }
   /**
@@ -1520,9 +1628,11 @@ var OpenApiGenerator = class {
       const typeCode = this.types.get(name);
       if (schemaCode) {
         output.push(schemaCode);
-        if (!schemaCode.includes(`export type ${name}`)) {
-          const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
-          output.push(`export type ${name} = z.infer<typeof ${schemaName}>;`);
+        const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
+        const typeName = toPascalCase(strippedName);
+        if (!schemaCode.includes(`export type ${typeName}`)) {
+          const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+          output.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
         }
         output.push("");
       } else if (typeCode) {
@@ -1556,6 +1666,7 @@ var OpenApiGenerator = class {
     const normalizedOutput = (0, import_node_path.normalize)(this.options.output);
     this.ensureDirectoryExists(normalizedOutput);
     (0, import_node_fs.writeFileSync)(normalizedOutput, output);
+    console.log(`  \u2713 Generated ${normalizedOutput}`);
   }
   /**
    * Resolve options for a specific context (request or response)
@@ -1837,7 +1948,8 @@ var OpenApiGenerator = class {
     const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
     if (schema.enum) {
       const jsdoc2 = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      const { schemaCode, typeCode } = generateEnum(name, schema.enum, {
+      const strippedName2 = stripPrefix(name, this.options.stripSchemaPrefix);
+      const { schemaCode, typeCode } = generateEnum(strippedName2, schema.enum, {
         prefix: this.options.prefix,
         suffix: this.options.suffix
       });
@@ -1846,7 +1958,8 @@ ${typeCode}`;
       this.schemas.set(name, enumSchemaCode);
       return;
     }
-    const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+    const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
+    const schemaName = `${toCamelCase(strippedName, { 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);
@@ -1862,7 +1975,8 @@ ${typeCode}`;
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
-      }
+      },
+      stripSchemaPrefix: this.options.stripSchemaPrefix
     });
     const isAlias = !!(schema.$ref && !schema.properties && !schema.allOf && !schema.oneOf && !schema.anyOf);
     const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, isAlias);
@@ -1966,6 +2080,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 (0, import_minimatch2.minimatch)(headerLower, patternLower);
+    });
+  }
   /**
    * Generate header parameter schemas for each operation
    * Header parameters are always string type (HTTP header semantics)
@@ -1988,7 +2120,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;
@@ -2046,7 +2178,8 @@ ${propsCode}
   generateQueryParamType(schema, param) {
     if (schema.$ref) {
       const refName = resolveRef(schema.$ref);
-      const schemaName = toCamelCase(refName, { prefix: this.options.prefix, suffix: this.options.suffix });
+      const strippedRefName = stripPrefix(refName, this.options.stripSchemaPrefix);
+      const schemaName = toCamelCase(strippedRefName, { prefix: this.options.prefix, suffix: this.options.suffix });
       return `${schemaName}Schema`;
     }
     if (schema.enum) {
@@ -2199,10 +2332,6 @@ function defineConfig(config) {
   OpenApiGenerator,
   SchemaGenerationError,
   SpecValidationError,
-  createFilterStatistics,
-  defineConfig,
-  formatFilterStatistics,
-  shouldIncludeOperation,
-  validateFilters
+  defineConfig
 });
 //# sourceMappingURL=index.js.map