import type Chunk from './chunk.ts';
import type { BaseOpts } from './util.ts';
import type { Offset, VirtualOffset } from './virtualOffset.ts';
import type { GenericFilehandle } from 'generic-filehandle2';
export interface Region {
    refId: number;
    start: number;
    end: number;
}
export interface RefIndex {
    binIndex: Record<number, Chunk[]>;
    stats?: {
        lineCount: number;
    };
}
export interface ParsedIndexBase<R extends RefIndex = RefIndex> {
    firstDataLine: VirtualOffset | undefined;
    refCount: number;
    maxBlockSize: number;
    indices: (refId: number) => R | undefined;
}
export declare function memoizeByRefId<T>(getIndices: (refId: number) => T | undefined, maxSize?: number): (refId: number) => T | undefined;
export default abstract class IndexFile<TParsed extends ParsedIndexBase = ParsedIndexBase> {
    filehandle: GenericFilehandle;
    renameRefSeq: (s: string) => string;
    private setupP?;
    constructor({ filehandle, renameRefSeq, }: {
        filehandle: GenericFilehandle;
        renameRefSeq?: (a: string) => string;
    });
    protected abstract _parse(opts: BaseOpts): Promise<TParsed>;
    abstract indexCov(refId: number, start?: number, end?: number): Promise<{
        start: number;
        end: number;
        score: number;
    }[]>;
    protected abstract reg2bins(min: number, max: number): readonly (readonly [number, number])[];
    protected abstract getLowestChunk(refIndex: RefIndex, min: number): Offset | undefined;
    blocksForRange(refId: number, min: number, max: number, opts?: BaseOpts): Promise<Chunk[]>;
    parse(opts?: BaseOpts): Promise<TParsed>;
    lineCount(refId: number, opts?: BaseOpts): Promise<number>;
    hasRefSeq(seqId: number, opts?: BaseOpts): Promise<boolean>;
    estimatedBytesForRegions(regions: Region[], opts?: BaseOpts): Promise<number>;
}