import type { RowNode } from '../../types/row.types';
import type { ColumnFilter, FilterModel, QuickFilterConfig } from '../../types/filter.types';
import type { ColumnDef } from '../../types/column.types';
import type { GridStore } from '../../core/grid-store';
import type { EventBus } from '../../event-bus/event-bus';
export declare class FilterEngine {
    private store;
    private eventBus;
    private filterModel;
    private quickFilter;
    constructor(store: GridStore, eventBus: EventBus);
    setFilterModel(model: FilterModel): void;
    setColumnFilter(colId: string, filter: ColumnFilter | null): void;
    clearColumnFilter(colId: string): void;
    clearAllFilters(): void;
    setQuickFilter(config: QuickFilterConfig): void;
    applyFilters(rows: RowNode[], columns: ColumnDef[]): RowNode[];
    /** `true` when at least one column filter or a quick filter is currently active — lets callers (e.g. `TreeDataService`) skip filtering work entirely when there's nothing to filter by. */
    hasActiveFilters(): boolean;
    /**
     * The single row-level predicate `applyFilters` runs for every row —
     * extracted as a public method so tree-aware filtering (`TreeDataService`)
     * can reuse the exact same column-filter/quick-filter logic per node
     * instead of re-implementing condition matching against a hierarchy.
     * Non-`'data'` rows (group headers, footers, etc.) always pass, matching
     * `applyFilters`'s prior inline behavior.
     */
    matchesRow(row: RowNode, columns: ColumnDef[]): boolean;
    /**
     * {@link matchesRow} against an already-compiled context, so a caller
     * filtering many rows builds that context once instead of once per row.
     */
    private matchesRowWith;
    /**
     * Tests a single `data` row against one *ad-hoc* {@link ColumnFilter} using the
     * exact same operator logic the display pipeline runs — but without touching
     * the active filter model or hiding anything. This is the matcher behind
     * predicate-based **row selection** (e.g. Photon AI's "select all rows where
     * status is active"): it lets callers highlight matching rows while every row
     * stays visible.
     *
     * Non-`'data'` rows (group headers, footers) never match. Pure and stateless.
     *
     * @param row    - The row to test.
     * @param filter - The column filter (operator + value) to evaluate.
     * @param col    - The column definition `filter` targets.
     * @returns `true` when the row's cell value satisfies the filter.
     */
    matchesColumnFilter(row: RowNode, filter: ColumnFilter, col: ColumnDef): boolean;
    getFilterModel(): FilterModel;
    isColumnFiltered(colId: string): boolean;
    private passesColumnFilters;
    private evaluateCondition;
    /**
     * The value a filter should be evaluated against: the renderer's displayed
     * text when the column has one, otherwise the raw cell value.
     *
     * Substituting a single value — rather than testing raw *and* displayed and
     * OR-ing the results — is what keeps negative operators honest: under an OR,
     * `notEquals "United States"` would pass on the raw `"US"` and silently match
     * every row.
     *
     * An array value is mapped element-wise so multi-value columns keep working
     * with `evaluateSetCondition`'s per-element membership test.
     */
    private displayValue;
    private passesQuickFilter;
}
//# sourceMappingURL=filter-engine.d.ts.map