import { Comparer } from '../Comparer';
import { SortOptimizations } from '../SortOptimizations';
import { Observable, OperatorFunction } from 'rxjs';
import { IChangeSet } from '../IChangeSet';
import { ISortedChangeSet } from '../ISortedChangeSet';
/**
 * Sorts using the specified comparer.
 * Returns the underlying ChangeSet as as per the system conventions.
 * The resulting changeset also exposes a sorted key value collection of of the underlying cached data
 * @typeparam TObject The type of the object.
 * @typeparam TKey The type of the key.
 * @param keyComparer The key comparer.
 * @param comparer The comparer.
 * @param sortOptimisations Sort optimization flags. Specify one or more sort optimizations
 * @param resort OnNext of this observable causes data to resort. This is required when the value which is sorted on mutable
 * @param comparerChangedObservable An observable comparer used to change the comparer on which the sorted list
 * @param resetThreshold The number of updates before the entire list is resorted (rather than inline sort)
 */
export declare function sort<TObject, TKey>(comparer?: Comparer<TObject>, comparerChangedObservable?: Observable<Comparer<TObject>>, resort?: Observable<unknown>, resetThreshold?: number, keyComparer?: Comparer<TKey>, sortOptimisations?: SortOptimizations): OperatorFunction<IChangeSet<TObject, TKey>, ISortedChangeSet<TObject, TKey>>;
declare type SortExpression<T> = Comparer<T> & {
    thenByAscending<Key extends keyof T>(key: Key): SortExpression<T>;
    thenByDescending<Key extends keyof T>(key: Key): SortExpression<T>;
};
export declare class SortComparer {
    static ascending<T, Key extends keyof T = keyof T>(key: Key): SortExpression<T>;
    static descending<T, Key extends keyof T = keyof T>(key: Key): SortExpression<T>;
}
export {};