import { ChangeSet, ChangedRange } from "../../state/src";
declare type A<T> = ReadonlyArray<T>;
export interface RangeValue {
    map(mapping: ChangeSet, from: number, to: number): Range<any> | null;
    bias: number;
    collapsed?: boolean;
}
export interface RangeComparator<T extends RangeValue> {
    compareRange(from: number, to: number, activeA: T[], activeB: T[]): void;
    compareCollapsed(from: number, to: number, byA: T, byB: T): void;
    comparePoints(pos: number, pointsA: T[], pointsB: T[]): void;
}
export interface RangeIterator<T extends RangeValue> {
    advance(pos: number, active: A<T>): void;
    advanceCollapsed(pos: number, value: T): void;
    point(value: T): void;
    ignoreRange(value: T): boolean;
    ignorePoint(value: T): boolean;
}
export declare class Range<T extends RangeValue> {
    readonly from: number;
    readonly to: number;
    readonly value: T;
    constructor(from: number, to: number, value: T);
    /** @internal */
    map(changes: ChangeSet, oldOffset: number, newOffset: number): Range<T> | null;
    /** @internal */
    move(offset: number): Range<T>;
    /** @internal Here so that we can put active ranges on a heap
     * and take them off at their end */
    readonly heapPos: number;
}
export declare type RangeFilter<T> = (from: number, to: number, value: T) => boolean;
export declare class RangeSet<T extends RangeValue> {
    length: number;
    size: number;
    local: A<Range<T>>;
    children: A<RangeSet<T>>;
    constructor(length: number, size: number, local: A<Range<T>>, children: A<RangeSet<T>>);
    update(added?: A<Range<T>>, filter?: RangeFilter<T> | null, filterFrom?: number, filterTo?: number): RangeSet<T>;
    /** @internal */
    updateInner(added: A<Range<T>>, filter: RangeFilter<T> | null, filterFrom: number, filterTo: number, offset: number, length: number): RangeSet<T>;
    grow(length: number): RangeSet<T>;
    collect(target: Range<T>[], offset: number): void;
    map(changes: ChangeSet): RangeSet<T>;
    private mapInner;
    forEach(f: (from: number, to: number, value: T) => void): void;
    private forEachInner;
    iter(): {
        next: () => Range<T> | void;
    };
    compare(other: RangeSet<T>, textDiff: A<ChangedRange>, comparator: RangeComparator<T>, oldLen: number): void;
    static iterateSpans<T extends RangeValue>(sets: A<RangeSet<T>>, from: number, to: number, iterator: RangeIterator<T>): void;
    static of<T extends RangeValue>(ranges: A<Range<T>> | Range<T>): RangeSet<T>;
    static empty: RangeSet<any>;
}
export {};