import type { DataType, InferStorage, Maybe } from '../../api/agDataType';
import type { AgFieldReference } from '../../api/agField';
import type { AgFilter, AgFilterCondition, AgFilterLogical } from '../../api/agFilter';
import type { AgFilterOperatorTypes } from '../../api/agFilterOperatorTypes';
import type { AgLimit } from '../../api/agLimit';
import type { AgSort } from '../../api/agSort';
import type { HydratedConditionDefinition, HydratedFilterDefinition, HydratedLogicalDefinition } from './hydrated';
export interface GroupDefinition {
    groupFields: AgFieldReference[];
    aggFields: AgFieldReference[];
}
export type WindowFunctionType = 'rank' | 'denseRank' | 'rowNumberRank';
export type RankWindowOptions = {
    topN?: number | null;
    bottomN?: number | null;
};
export type DenseRankWindowOptions = Record<string, never>;
export type RowNumberWindowOptions = Record<string, never>;
export type WindowOptions<T extends WindowFunctionType = WindowFunctionType> = T extends 'rank' ? RankWindowOptions : T extends 'denseRank' ? DenseRankWindowOptions : T extends 'rowNumberRank' ? RowNumberWindowOptions : never;
export type WindowDefinition<T extends WindowFunctionType = WindowFunctionType> = {
    field: AgFieldReference;
    functionType: T;
    orderBy?: AgSort[];
    options?: WindowOptions<T>;
};
export declare const isConditionDefinition: (def: AgFilter | HydratedFilterDefinition) => def is AgFilterCondition<any, Record<string, any>> | HydratedConditionDefinition;
export declare const isLogicalDefinition: (def: AgFilter | HydratedFilterDefinition) => def is AgFilterLogical | HydratedLogicalDefinition;
export type OperatorValueShape = 'none' | 'scalar' | 'array' | 'range';
export type OperatorDefinition<TDataType extends DataType = DataType, TFilterValue = any, TParsedFilterValue = TFilterValue, TConditionOptions = Record<string, any>> = {
    operator: keyof AgFilterOperatorTypes;
    supports: TDataType[];
    valueShape: OperatorValueShape;
    parseFilterValue?: (value: TFilterValue, options?: TConditionOptions) => TParsedFilterValue;
    fn: (fieldValue: Maybe<InferStorage<TDataType>>, filterValue: TParsedFilterValue, options?: TConditionOptions) => boolean;
};
export interface DataQuery {
    kind: 'dataQuery';
    fields: AgFieldReference[];
    group?: GroupDefinition;
    sort?: AgSort[];
    filter?: AgFilter;
    window?: WindowDefinition[];
    limit?: AgLimit;
    /**
     * When set, the query aggregates over the materialised result of this prior query
     * rather than scanning raw sources. Used by grand-total rows to re-aggregate
     * already-filtered grouped results without re-executing the source scan.
     */
    from?: DataQuery;
    /**
     * When `true`, the query produces a single grand-total row. Dimension
     * fields are retained for join resolution (so the row scope matches
     * the grouped query) but are not grouped on.
     */
    grandTotal?: boolean;
}