import * as i0 from "@angular/core";
/**
 * Validation message severity levels
 */
export type ValidationSeverity = 'error' | 'warning' | 'info';
/**
 * Validation message structure
 */
export interface ValidationMessage {
    id: string;
    severity: ValidationSeverity;
    message: string;
    icon?: string;
}
/**
 * Validation rule function signature
 * Returns null if valid, or ValidationMessage if invalid
 */
export type ValidationRule<T = any> = (context: T) => ValidationMessage | null;
/**
 * Generic reactive validation service for filter components
 *
 * Features:
 * - Declarative validation rules
 * - Real-time reactive validation
 * - Multiple validation messages per field
 * - Severity levels (error, warning, info)
 * - Type-safe validation contexts
 *
 * Usage:
 * ```typescript
 * export class FilterComponent {
 *   validationService = inject(FilterValidationService);
 *   filterRows = signal<any[]>([]);
 *
 *   constructor() {
 *     // Register validation rules
 *     this.validationService.registerRule({
 *       id: 'multiple-ranges',
 *       severity: 'warning',
 *       validate: (rows) => this.validateMultipleRanges(rows)
 *     });
 *
 *     // Connect reactive state
 *     effect(() => {
 *       this.validationService.setContext(this.filterRows());
 *     });
 *   }
 *
 *   readonly validationMessages = this.validationService.messages;
 *   readonly hasErrors = this.validationService.hasErrors;
 *   readonly hasWarnings = this.validationService.hasWarnings;
 * }
 * ```
 */
export declare class FilterValidationService<TContext = any> {
    private readonly _context;
    private readonly _rules;
    /**
     * All active validation messages
     */
    readonly messages: import("@angular/core").Signal<ValidationMessage[]>;
    /**
     * Error messages only
     */
    readonly errors: import("@angular/core").Signal<ValidationMessage[]>;
    /**
     * Warning messages only
     */
    readonly warnings: import("@angular/core").Signal<ValidationMessage[]>;
    /**
     * Info messages only
     */
    readonly infos: import("@angular/core").Signal<ValidationMessage[]>;
    /**
     * Check if any errors exist
     */
    readonly hasErrors: import("@angular/core").Signal<boolean>;
    /**
     * Check if any warnings exist
     */
    readonly hasWarnings: import("@angular/core").Signal<boolean>;
    /**
     * Check if any info messages exist
     */
    readonly hasInfos: import("@angular/core").Signal<boolean>;
    /**
     * Check if any messages exist
     */
    readonly hasMessages: import("@angular/core").Signal<boolean>;
    /**
     * Set the validation context (typically the component state)
     * This triggers re-validation of all rules
     */
    setContext(context: TContext): void;
    /**
     * Register a validation rule
     */
    registerRule(id: string, rule: ValidationRule<TContext>): void;
    /**
     * Unregister a validation rule
     */
    unregisterRule(id: string): void;
    /**
     * Clear all validation rules
     */
    clearRules(): void;
    /**
     * Clear the validation context
     */
    clearContext(): void;
    /**
     * Reset the service (clear context and rules)
     */
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterValidationService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FilterValidationService<any>>;
}
/**
 * Common validation rules that can be reused across filter types
 */
export declare class CommonFilterValidationRules {
    /**
     * Validate multiple ranges in number-range filters
     * Only warns if multiple ranges have the SAME mode (include or exclude)
     * Mixed modes (e.g., include range + exclude range) are valid
     */
    static multipleRanges(rows: any[]): ValidationMessage | null;
    /**
     * Validate overlapping ranges
     */
    static overlappingRanges(rows: any[]): ValidationMessage | null;
    /**
     * Validate empty rows
     */
    static emptyRows(rows: any[]): ValidationMessage | null;
    /**
     * Validate duplicate values in discrete rows
     */
    static duplicateValues(rows: any[]): ValidationMessage | null;
    /**
     * Validate conflicting include/exclude values
     */
    static conflictingModes(rows: any[]): ValidationMessage | null;
    /**
     * Validate row count limits
     */
    static rowCountLimit(rows: any[], limit: number, type?: string): ValidationMessage | null;
    /**
     * Validate out-of-bounds values for range filters
     */
    static outOfBounds(rows: any[], min: number, max: number): ValidationMessage | null;
}