export declare enum DataGridSortingStrategy {
    Descending = "descending",
    Ascending = "ascending"
}
export type DataGridSortingDefinition<TData> = {
    readonly selector: KeyPath.Of<TData>;
    readonly strategy: DataGridSortingStrategy;
};
export type DataGridRankedSortDefinition<TData> = DataGridSortingDefinition<TData> & {
    readonly rank: number;
};
export type DataGridSorting<TData> = DataGridSortingDefinition<TData> | Array<DataGridSortingDefinition<TData>>;
interface SortableComponent<TData> {
    sorting?: DataGridSorting<TData> | undefined;
    readonly sortingChange?: EventDispatcher<Array<DataGridRankedSortDefinition<TData>>>;
}
export declare class DataGridSortingController<TData> {
    readonly host: SortableComponent<TData>;
    constructor(host: SortableComponent<TData>);
    get enabled(): boolean;
    get(): DataGridRankedSortDefinition<TData>[];
    set(sorting: DataGridSorting<TData>): void;
    private toNormalizedRanked;
    reset(): void;
    /**
     * Toggles the sorting strategy of the provided key path.
     * If a modifier key is pressed, the sorting will be added to the existing sorting definitions.
     *
     * @param selector - The key path of the data to sort by
     * @param strategy - The sorting strategy to use forcefully. If not provided, the strategy will be toggled between ascending, descending, and unsorted
     */
    toggle(selector: KeyPath.Of<TData>, strategy?: DataGridSortingStrategy): void;
    /**
     * Sorts the provided data based on the current sorting definitions
     * @param data - The data to sort
     * @returns - The sorted data
     */
    toSorted(data: Array<TData>): TData[];
    toSortedBy<T>(data: Array<T>, extractor: (data: T) => TData): T[];
}
export {};
//# sourceMappingURL=DataGridSortingController.d.ts.map