/**
 * Category-Based Filtering
 *
 * Enables CI to fail only on specific vulnerability categories,
 * allowing gradual rollout (e.g., "only block prompt injection")
 * and fine-grained control over which findings are blocking.
 *
 * @example
 * // Fail only on AI-related and secret categories
 * --fail-on-categories ai-*,secrets-*
 *
 * @example
 * // Combined with severity
 * --fail-on high --fail-on-categories ai-*
 * // Only fail on high+ AI findings
 */
import type { VulnerabilityCategory, Vulnerability, VulnerabilitySeverity } from './types';
/**
 * Category group definitions for wildcard expansion
 *
 * These groups allow users to specify broad categories like "ai-*"
 * which expand to all AI-related vulnerability categories.
 */
export declare const CATEGORY_GROUPS: Record<string, VulnerabilityCategory[]>;
/**
 * All known valid category names for validation
 */
export declare const ALL_CATEGORIES: VulnerabilityCategory[];
/**
 * Normalize category name for comparison
 * - Converts to lowercase
 * - Converts hyphens to underscores
 * - Trims whitespace
 *
 * @example
 * normalizeCategory('SQL-Injection') // 'sql_injection'
 * normalizeCategory('high_entropy_string') // 'high_entropy_string'
 */
export declare function normalizeCategory(category: string): string;
/**
 * Expand a wildcard pattern or single category to a list of categories
 *
 * @param pattern - Category name or wildcard (e.g., 'sql_injection', 'ai-*')
 * @returns Array of matching categories
 *
 * @example
 * expandCategoryPattern('ai-*') // Returns all ai_* categories
 * expandCategoryPattern('sql_injection') // Returns ['sql_injection']
 * expandCategoryPattern('unknown-*') // Returns []
 */
export declare function expandCategoryPattern(pattern: string): VulnerabilityCategory[];
/**
 * Check if a category matches any pattern in the filter list
 *
 * @param category - The vulnerability category to check
 * @param patterns - Array of category patterns (names or wildcards)
 * @returns true if the category matches any pattern
 *
 * @example
 * matchesAnyCategory('ai_prompt_injection', ['ai-*']) // true
 * matchesAnyCategory('sql_injection', ['ai-*']) // false
 * matchesAnyCategory('sql_injection', ['sql_injection', 'xss']) // true
 */
export declare function matchesAnyCategory(category: VulnerabilityCategory, patterns: string[]): boolean;
/**
 * Check if vulnerabilities should cause failure based on category filter
 *
 * When both category patterns and severity threshold are provided,
 * BOTH conditions must match for a finding to cause failure.
 *
 * @param vulnerabilities - List of vulnerabilities to check
 * @param categoryPatterns - Category patterns to filter on
 * @param severityThreshold - Optional severity threshold (both must match)
 * @returns true if any vulnerability matches and should cause failure
 *
 * @example
 * // Only fail on AI findings
 * shouldFailOnCategories(vulns, ['ai-*'])
 *
 * @example
 * // Only fail on HIGH+ AI findings
 * shouldFailOnCategories(vulns, ['ai-*'], 'high')
 */
export declare function shouldFailOnCategories(vulnerabilities: Vulnerability[], categoryPatterns: string[], severityThreshold?: VulnerabilitySeverity): boolean;
/**
 * Get the categories that matched the filter from vulnerabilities
 * Useful for error messages showing which categories caused failure
 */
export declare function getMatchingCategories(vulnerabilities: Vulnerability[], categoryPatterns: string[], severityThreshold?: VulnerabilitySeverity): VulnerabilityCategory[];
/**
 * Parse comma-separated category string into array
 *
 * @param input - Comma-separated category string
 * @returns Array of trimmed category patterns
 *
 * @example
 * parseCategoryList('ai-*, secrets-*') // ['ai-*', 'secrets-*']
 * parseCategoryList('sql_injection, xss') // ['sql_injection', 'xss']
 */
export declare function parseCategoryList(input: string): string[];
/**
 * Validate category names, separating valid from invalid
 *
 * @param categories - Array of category patterns to validate
 * @returns Object with valid and invalid category arrays
 *
 * @example
 * validateCategories(['ai-*', 'sql_injection', 'fake_category'])
 * // { valid: ['ai-*', 'sql_injection'], invalid: ['fake_category'] }
 */
export declare function validateCategories(categories: string[]): {
    valid: string[];
    invalid: string[];
};
/**
 * Get a human-readable list of available category groups
 * Useful for help text and error messages
 */
export declare function getAvailableCategoryGroups(): string[];
/**
 * Get the count of categories in each group
 * Useful for documentation and help text
 */
export declare function getCategoryGroupCounts(): Record<string, number>;
//# sourceMappingURL=category-filter.d.ts.map