@cerios/openapi-to-zod 0.4.0 → 0.5.1

package/dist/index.d.mts

@@ -187,6 +187,98 @@ interface OpenApiGeneratorOptions {
      * Always generates Zod schemas for runtime validation
      */
     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[];
@@ -311,6 +403,7 @@ declare class OpenApiGenerator {
     private requestOptions;
     private responseOptions;
     private needsZodImport;
+    private filterStats;
     constructor(options: OpenApiGeneratorOptions);
     /**
      * Generate schemas as a string (without writing to file)
@@ -377,6 +470,11 @@ declare class OpenApiGenerator {
      * Generate query parameter schemas for each operation
      */
     private generateQueryParameterSchemas;
+    /**
+     * Generate header parameter schemas for each operation
+     * Header parameters are always string type (HTTP header semantics)
+     */
+    private generateHeaderParameterSchemas;
     /**
      * Generate Zod type for a query parameter schema
      */
@@ -412,4 +510,55 @@ declare class OpenApiGenerator {
     private generateStats;
 }
 
-export { CircularReferenceError, CliOptionsError, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, GeneratorError, type OpenAPISpec, OpenApiGenerator, type OpenApiGeneratorOptions, SchemaGenerationError, SpecValidationError, defineConfig };
+/**
+ * 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 ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, type FilterStatistics, GeneratorError, type OpenAPISpec, OpenApiGenerator, type OpenApiGeneratorOptions, type OperationFilters, SchemaGenerationError, SpecValidationError, createFilterStatistics, defineConfig, formatFilterStatistics, shouldIncludeOperation, validateFilters };

package/dist/index.d.ts

@@ -187,6 +187,98 @@ interface OpenApiGeneratorOptions {
      * Always generates Zod schemas for runtime validation
      */
     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[];
@@ -311,6 +403,7 @@ declare class OpenApiGenerator {
     private requestOptions;
     private responseOptions;
     private needsZodImport;
+    private filterStats;
     constructor(options: OpenApiGeneratorOptions);
     /**
      * Generate schemas as a string (without writing to file)
@@ -377,6 +470,11 @@ declare class OpenApiGenerator {
      * Generate query parameter schemas for each operation
      */
     private generateQueryParameterSchemas;
+    /**
+     * Generate header parameter schemas for each operation
+     * Header parameters are always string type (HTTP header semantics)
+     */
+    private generateHeaderParameterSchemas;
     /**
      * Generate Zod type for a query parameter schema
      */
@@ -412,4 +510,55 @@ declare class OpenApiGenerator {
     private generateStats;
 }
 
-export { CircularReferenceError, CliOptionsError, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, GeneratorError, type OpenAPISpec, OpenApiGenerator, type OpenApiGeneratorOptions, SchemaGenerationError, SpecValidationError, defineConfig };
+/**
+ * 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 ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, type FilterStatistics, GeneratorError, type OpenAPISpec, OpenApiGenerator, type OpenApiGeneratorOptions, type OperationFilters, SchemaGenerationError, SpecValidationError, createFilterStatistics, defineConfig, formatFilterStatistics, shouldIncludeOperation, validateFilters };

package/dist/index.js

@@ -28,7 +28,11 @@ __export(src_exports, {
   OpenApiGenerator: () => OpenApiGenerator,
   SchemaGenerationError: () => SchemaGenerationError,
   SpecValidationError: () => SpecValidationError,
-  defineConfig: () => defineConfig
+  createFilterStatistics: () => createFilterStatistics,
+  defineConfig: () => defineConfig,
+  formatFilterStatistics: () => formatFilterStatistics,
+  shouldIncludeOperation: () => shouldIncludeOperation,
+  validateFilters: () => validateFilters
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -1279,6 +1283,140 @@ _PropertyGenerator.INCLUSION_RULES = {
 };
 var PropertyGenerator = _PropertyGenerator;
 
+// src/utils/operation-filters.ts
+var import_minimatch = require("minimatch");
+function createFilterStatistics() {
+  return {
+    totalOperations: 0,
+    includedOperations: 0,
+    filteredByTags: 0,
+    filteredByPaths: 0,
+    filteredByMethods: 0,
+    filteredByOperationIds: 0,
+    filteredByDeprecated: 0
+  };
+}
+function matchesAnyPattern(value, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  if (!value) {
+    return false;
+  }
+  return patterns.some((pattern) => (0, import_minimatch.minimatch)(value, pattern));
+}
+function containsAny(arr, values) {
+  if (!values || values.length === 0) {
+    return false;
+  }
+  if (!arr || arr.length === 0) {
+    return false;
+  }
+  return values.some((value) => arr.includes(value));
+}
+function shouldIncludeOperation(operation, path, method, filters, stats) {
+  if (!filters) {
+    return true;
+  }
+  const methodLower = method.toLowerCase();
+  const operationId = operation == null ? void 0 : operation.operationId;
+  const tags = (operation == null ? void 0 : operation.tags) || [];
+  const deprecated = (operation == null ? void 0 : operation.deprecated) === true;
+  if (filters.includeTags && filters.includeTags.length > 0) {
+    if (!containsAny(tags, filters.includeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.includePaths && filters.includePaths.length > 0) {
+    if (!matchesAnyPattern(path, filters.includePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.includeMethods && filters.includeMethods.length > 0) {
+    const methodsLower = filters.includeMethods.map((m) => m.toLowerCase());
+    if (!methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.includeOperationIds && filters.includeOperationIds.length > 0) {
+    if (!matchesAnyPattern(operationId, filters.includeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  if (filters.excludeDeprecated === true && deprecated) {
+    if (stats) stats.filteredByDeprecated++;
+    return false;
+  }
+  if (filters.excludeTags && filters.excludeTags.length > 0) {
+    if (containsAny(tags, filters.excludeTags)) {
+      if (stats) stats.filteredByTags++;
+      return false;
+    }
+  }
+  if (filters.excludePaths && filters.excludePaths.length > 0) {
+    if (matchesAnyPattern(path, filters.excludePaths)) {
+      if (stats) stats.filteredByPaths++;
+      return false;
+    }
+  }
+  if (filters.excludeMethods && filters.excludeMethods.length > 0) {
+    const methodsLower = filters.excludeMethods.map((m) => m.toLowerCase());
+    if (methodsLower.includes(methodLower)) {
+      if (stats) stats.filteredByMethods++;
+      return false;
+    }
+  }
+  if (filters.excludeOperationIds && filters.excludeOperationIds.length > 0) {
+    if (matchesAnyPattern(operationId, filters.excludeOperationIds)) {
+      if (stats) stats.filteredByOperationIds++;
+      return false;
+    }
+  }
+  return true;
+}
+function validateFilters(stats, filters) {
+  if (!filters || stats.totalOperations === 0) {
+    return;
+  }
+  if (stats.includedOperations === 0) {
+    console.warn(
+      `\u26A0\uFE0F  Warning: All ${stats.totalOperations} operations were filtered out. Check your operationFilters configuration.`
+    );
+    const filterBreakdown = [];
+    if (stats.filteredByTags > 0) filterBreakdown.push(`${stats.filteredByTags} by tags`);
+    if (stats.filteredByPaths > 0) filterBreakdown.push(`${stats.filteredByPaths} by paths`);
+    if (stats.filteredByMethods > 0) filterBreakdown.push(`${stats.filteredByMethods} by methods`);
+    if (stats.filteredByOperationIds > 0) filterBreakdown.push(`${stats.filteredByOperationIds} by operationIds`);
+    if (stats.filteredByDeprecated > 0) filterBreakdown.push(`${stats.filteredByDeprecated} by deprecated flag`);
+    if (filterBreakdown.length > 0) {
+      console.warn(`   Filtered: ${filterBreakdown.join(", ")}`);
+    }
+  }
+}
+function formatFilterStatistics(stats) {
+  if (stats.totalOperations === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("Operation Filtering:");
+  lines.push(`  Total operations: ${stats.totalOperations}`);
+  lines.push(`  Included operations: ${stats.includedOperations}`);
+  const filteredCount = stats.filteredByTags + stats.filteredByPaths + stats.filteredByMethods + stats.filteredByOperationIds + stats.filteredByDeprecated;
+  if (filteredCount > 0) {
+    lines.push(`  Filtered operations: ${filteredCount}`);
+    if (stats.filteredByTags > 0) lines.push(`    - By tags: ${stats.filteredByTags}`);
+    if (stats.filteredByPaths > 0) lines.push(`    - By paths: ${stats.filteredByPaths}`);
+    if (stats.filteredByMethods > 0) lines.push(`    - By methods: ${stats.filteredByMethods}`);
+    if (stats.filteredByOperationIds > 0) lines.push(`    - By operationIds: ${stats.filteredByOperationIds}`);
+    if (stats.filteredByDeprecated > 0) lines.push(`    - By deprecated: ${stats.filteredByDeprecated}`);
+  }
+  return lines.join("\n");
+}
+
 // src/openapi-generator.ts
 var OpenApiGenerator = class {
   constructor(options) {
@@ -1290,6 +1428,7 @@ var OpenApiGenerator = class {
     this.schemaUsageMap = /* @__PURE__ */ new Map();
     this.schemaTypeModeMap = /* @__PURE__ */ new Map();
     this.needsZodImport = false;
+    this.filterStats = createFilterStatistics();
     var _a, _b, _c;
     if (!options.input) {
       throw new ConfigurationError("Input path is required", { providedOptions: options });
@@ -1307,7 +1446,8 @@ var OpenApiGenerator = class {
       showStats: (_c = options.showStats) != null ? _c : true,
       nativeEnumType: options.nativeEnumType || "union",
       request: options.request,
-      response: options.response
+      response: options.response,
+      operationFilters: options.operationFilters
     };
     try {
       const fs = require("fs");
@@ -1412,6 +1552,8 @@ var OpenApiGenerator = class {
       this.generateComponentSchema(name, schema);
     }
     this.generateQueryParameterSchemas();
+    this.generateHeaderParameterSchemas();
+    validateFilters(this.filterStats, this.options.operationFilters);
     const orderedSchemaNames = this.topologicalSort();
     const output = ["// Auto-generated by @cerios/openapi-to-zod", "// Do not edit this file manually", ""];
     if (this.options.showStats === true) {
@@ -1505,9 +1647,16 @@ var OpenApiGenerator = class {
     const requestSchemas = /* @__PURE__ */ new Set();
     const responseSchemas = /* @__PURE__ */ new Set();
     if (this.spec.paths) {
-      for (const [, pathItem] of Object.entries(this.spec.paths)) {
-        for (const [, operation] of Object.entries(pathItem)) {
+      for (const [path, pathItem] of Object.entries(this.spec.paths)) {
+        const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+        for (const method of methods) {
+          const operation = pathItem[method];
           if (typeof operation !== "object" || !operation) continue;
+          this.filterStats.totalOperations++;
+          if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters, this.filterStats)) {
+            continue;
+          }
+          this.filterStats.includedOperations++;
           if ("requestBody" in operation && operation.requestBody && typeof operation.requestBody === "object" && "content" in operation.requestBody && operation.requestBody.content) {
             for (const mediaType of Object.values(operation.requestBody.content)) {
               if (mediaType && typeof mediaType === "object" && "schema" in mediaType && mediaType.schema) {
@@ -1857,12 +2006,15 @@ ${typeCode}`;
     if (!this.spec.paths) {
       return;
     }
-    for (const [_path, pathItem] of Object.entries(this.spec.paths)) {
+    for (const [path, pathItem] of Object.entries(this.spec.paths)) {
       if (!pathItem || typeof pathItem !== "object") continue;
       const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
       for (const method of methods) {
         const operation = pathItem[method];
         if (!operation) continue;
+        if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
+          continue;
+        }
         if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
           continue;
         }
@@ -1923,6 +2075,80 @@ ${propsCode}
         const jsdoc = `/**
  * Query parameters for ${operation.operationId}
  */
+`;
+        const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
+        this.schemas.set(schemaName, fullSchemaCode);
+        this.needsZodImport = true;
+      }
+    }
+  }
+  /**
+   * Generate header parameter schemas for each operation
+   * Header parameters are always string type (HTTP header semantics)
+   */
+  generateHeaderParameterSchemas() {
+    var _a;
+    if (!this.spec.paths) {
+      return;
+    }
+    for (const [path, pathItem] of Object.entries(this.spec.paths)) {
+      if (!pathItem || typeof pathItem !== "object") continue;
+      const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+      for (const method of methods) {
+        const operation = pathItem[method];
+        if (!operation) continue;
+        if (!shouldIncludeOperation(operation, path, method, this.options.operationFilters)) {
+          continue;
+        }
+        if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
+          continue;
+        }
+        const headerParams = operation.parameters.filter(
+          (param) => param && typeof param === "object" && param.in === "header"
+        );
+        if (headerParams.length === 0) {
+          continue;
+        }
+        const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+        const schemaName = `${pascalOperationId}HeaderParams`;
+        if (!this.schemaDependencies.has(schemaName)) {
+          this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
+        }
+        const properties = {};
+        for (const param of headerParams) {
+          const paramName = param.name;
+          const paramSchema = param.schema;
+          if (!paramSchema) continue;
+          let zodType = "z.string()";
+          if (param.description && this.requestOptions.includeDescriptions) {
+            if (this.requestOptions.useDescribe) {
+              zodType = `${zodType}.describe(${JSON.stringify(param.description)})`;
+            }
+          }
+          zodType = `${zodType}.optional()`;
+          properties[paramName] = zodType;
+          if (paramSchema.$ref) {
+            const refName = resolveRef(paramSchema.$ref);
+            (_a = this.schemaDependencies.get(schemaName)) == null ? void 0 : _a.add(refName);
+          }
+        }
+        const objectMode = this.requestOptions.mode;
+        const zodMethod = objectMode === "strict" ? "strictObject" : objectMode === "loose" ? "looseObject" : "object";
+        const propsCode = Object.entries(properties).map(([key, value]) => {
+          const needsQuotes = !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+          const quotedKey = needsQuotes ? `"${key}"` : key;
+          return `  ${quotedKey}: ${value}`;
+        }).join(",\n");
+        const schemaCode = `z.${zodMethod}({
+${propsCode}
+})`;
+        const operationName = pascalOperationId;
+        const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
+        const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
+        const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}HeaderParamsSchema`;
+        const jsdoc = `/**
+ * Header parameters for ${operation.operationId}
+ */
 `;
         const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
         this.schemas.set(schemaName, fullSchemaCode);
@@ -2200,15 +2426,23 @@ ${props.join("\n")}
         stats.withConstraints++;
       }
     }
-    return [
+    const output = [
       "// Generation Statistics:",
       `//   Total schemas: ${stats.totalSchemas}`,
       `//   Enums: ${stats.enums}`,
       `//   Circular references: ${stats.withCircularRefs}`,
       `//   Discriminated unions: ${stats.withDiscriminators}`,
-      `//   With constraints: ${stats.withConstraints}`,
-      `//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`
+      `//   With constraints: ${stats.withConstraints}`
     ];
+    if (this.options.operationFilters && this.filterStats.totalOperations > 0) {
+      output.push("//");
+      const filterStatsStr = formatFilterStatistics(this.filterStats);
+      for (const line of filterStatsStr.split("\n")) {
+        output.push(`//   ${line}`);
+      }
+    }
+    output.push(`//   Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    return output;
   }
 };
 
@@ -2226,6 +2460,10 @@ function defineConfig(config) {
   OpenApiGenerator,
   SchemaGenerationError,
   SpecValidationError,
-  defineConfig
+  createFilterStatistics,
+  defineConfig,
+  formatFilterStatistics,
+  shouldIncludeOperation,
+  validateFilters
 });
 //# sourceMappingURL=index.js.map