import { BUILT_IN_MATCHERS, getGlobalMatchers, registerMatcher, unregisterMatcher, type BuiltInMatchMode, type FilterMatcher } from './_matchers';
export { registerMatcher, unregisterMatcher, BUILT_IN_MATCHERS, getGlobalMatchers };
export type { FilterMatcher, BuiltInMatchMode };
export type FilterOperator = 'and' | 'or';
export interface FilterConstraint<TMode extends string = string> {
    value: unknown;
    matchMode?: TMode;
}
export interface FilterRuleSimple<TMode extends string = string> {
    field: string | string[];
    value: unknown;
    matchMode?: TMode;
    operator?: never;
    constraints?: never;
}
export interface FilterRuleComposite<TMode extends string = string> {
    field: string | string[];
    operator?: FilterOperator;
    constraints: FilterConstraint<TMode>[];
    value?: never;
    matchMode?: never;
}
export type FilterRule<TMode extends string = string> = FilterRuleSimple<TMode> | FilterRuleComposite<TMode>;
export interface UseFilterOptions<T, TMode extends string = BuiltInMatchMode> {
    data: T[];
    /** Shorthand: target field for a single-rule filter. Use `rules` / `defaultRules` for multi-rule setups. */
    field?: string | string[];
    /** Shorthand: value for the single-rule filter declared via `field`. */
    value?: unknown;
    /** Shorthand: match mode for the single-rule filter declared via `field`. Defaults to `contains`. */
    matchMode?: TMode;
    /** Shorthand: callback when the single-rule value changes. */
    onValueChange?: (value: unknown) => void;
    /** Multi-rule controlled state. Omit and use `field/value` for a single rule. */
    rules?: FilterRule<TMode>[];
    /** Multi-rule uncontrolled initial state. */
    defaultRules?: FilterRule<TMode>[];
    matchers?: Partial<Record<TMode, FilterMatcher>> & Record<string, FilterMatcher>;
    filterLocale?: string;
    filterDelay?: number;
    /** When true, `filteredData` is returned as-is; the consumer is responsible for filtering (server-side). */
    lazy?: boolean;
    /** Fires after rules settle (honours `filterDelay`). The consumer is expected to fetch a new `data` slice. */
    onLazyLoad?: (event: LazyFilterEvent<TMode>) => void;
    onRulesChange?: (rules: FilterRule<TMode>[]) => void;
}
export interface LazyFilterEvent<TMode extends string = string> {
    rules: FilterRule<TMode>[];
    filterLocale?: string;
}
export interface FilterConstraintCursor<TMode extends string = string> {
    value: unknown;
    matchMode: TMode | undefined;
    setValue: (value: unknown) => void;
    setMatchMode: (matchMode: TMode) => void;
    remove: () => void;
}
export interface FilterRuleCursor<TMode extends string = string> {
    field: string | string[];
    value: unknown;
    matchMode: TMode | undefined;
    operator: FilterOperator | undefined;
    constraints: FilterConstraint<TMode>[] | undefined;
    setValue: (value: unknown) => void;
    setMatchMode: (matchMode: TMode) => void;
    setOperator: (operator: FilterOperator) => void;
    addConstraint: (matchMode?: TMode) => void;
    constraint: (index: number) => FilterConstraintCursor<TMode> | undefined;
    remove: () => void;
    clear: () => void;
}
export interface UseFilterReturn<T, TMode extends string = string> {
    rules: FilterRule<TMode>[];
    filteredData: T[];
    isFiltered: boolean;
    setRules: (rules: FilterRule<TMode>[]) => void;
    setValue: (ruleIndex: number, value: unknown) => void;
    setMatchMode: (ruleIndex: number, matchMode: TMode) => void;
    setOperator: (ruleIndex: number, operator: FilterOperator) => void;
    setConstraintValue: (ruleIndex: number, constraintIndex: number, value: unknown) => void;
    setConstraintMatchMode: (ruleIndex: number, constraintIndex: number, matchMode: TMode) => void;
    addRule: (rule: FilterRule<TMode>) => void;
    removeRule: (ruleIndex: number) => void;
    clearRule: (ruleIndex: number) => void;
    addConstraint: (ruleIndex: number, matchMode?: TMode) => void;
    removeConstraint: (ruleIndex: number, constraintIndex: number) => void;
    clearAll: () => void;
    rule: (ruleKey: number | string) => FilterRuleCursor<TMode> | undefined;
    match: (item: T) => boolean;
    matchers: Readonly<Record<string, FilterMatcher>>;
}
export declare function matchRule<T, TMode extends string>(item: T, rule: FilterRule<TMode>, matchers: Record<string, FilterMatcher>, locale?: string): boolean;
export declare function useFilter<T, TMode extends string = BuiltInMatchMode>(options: UseFilterOptions<T, TMode>): UseFilterReturn<T, TMode>;
export declare function ruleHasValue<TMode extends string>(rule: FilterRule<TMode>): boolean;