/**
 * Bytes a source has already downloaded and no longer holds in its window.
 *
 * HttpSource keeps one contiguous window. A seek outside it started the window
 * over at the new place and threw the old one away, and the window sliding on
 * dropped whatever fell off its back — so going back to a stretch that had
 * been watched a minute earlier downloaded it again, at link speed, while a
 * native <video> on the same file (whose media cache keeps what it fetched)
 * jumped there at once. This is that memory: what the window lets go of is
 * kept here instead, within a budget, and the window takes it back when a read
 * or a seek lands on it.
 *
 * Kept as chunks of at most CHUNK_BYTES so a budget can be met by evicting
 * whole chunks, least recently used first. Chunks never overlap: what is
 * already kept is the same bytes of the same file, so only the parts nothing
 * covers yet are added.
 */
export declare class SeenRanges {
    private budget;
    /** Sorted by start, non-overlapping. */
    private chunks;
    private total;
    private tick;
    constructor(budget: number);
    /** Bytes held right now. */
    get size(): number;
    setBudget(bytes: number): void;
    clear(): void;
    /**
     * Keep `bytes`, which are the file's bytes from `start`. A span larger than
     * the whole budget keeps the part around `focus` — where the viewer was —
     * rather than copying all of it only to evict most of it again.
     */
    keep(start: number, bytes: Uint8Array, focus?: number): void;
    /**
     * The contiguous run of kept bytes starting exactly at `offset`, at most
     * `max` long, as views in order — empty when `offset` is not kept.
     */
    runFrom(offset: number, max: number): Uint8Array[];
    /** A copy of [offset, offset + length) if every byte of it is kept. */
    read(offset: number, length: number): Uint8Array | null;
    private insert;
    private evict;
}
//# sourceMappingURL=SeenRanges.d.ts.map