import BAI from './bai.ts';
import CSI from './csi.ts';
import BAMFeature from './record.ts';
import type Chunk from './chunk.ts';
import type { Bytes } from './record.ts';
import type { BamOpts, BaseOpts } from './util.ts';
import type { GenericFilehandle } from 'generic-filehandle2';
export interface BamRecordLike {
    ref_id: number;
    start: number;
    end: number;
    name: string;
    fileOffset: number;
    next_pos: number;
    next_refid: number;
    flags: number;
    tags: Record<string, unknown>;
}
export type BamRecordClass<T extends BamRecordLike = BAMFeature> = new (args: {
    bytes: Bytes;
    fileOffset: number;
    dataView: DataView;
}) => T;
export declare const BAM_MAGIC = 21840194;
interface ChunkEntry<T> {
    bytes: number;
    features: T[];
}
export declare const DEFAULT_MAX_CACHE_BYTES: number;
declare class ChunkFeatureCache<T> {
    maxBytes: number;
    private entries;
    private bytes;
    constructor(maxBytes: number);
    get size(): number;
    get byteSize(): number;
    get(key: string): ChunkEntry<T> | undefined;
    set(key: string, entry: ChunkEntry<T>): void;
    delete(key: string): void;
    clear(): void;
    [Symbol.iterator](): MapIterator<[string, ChunkEntry<T>]>;
}
export default class BamFile<T extends BamRecordLike = BAMFeature> {
    renameRefSeq: (a: string) => string;
    bam: GenericFilehandle;
    header?: string;
    chrToIndex?: Record<string, number>;
    indexToChr?: {
        refName: string;
        length: number;
    }[];
    index?: BAI | CSI;
    htsget: boolean;
    headerP?: ReturnType<BamFile<T>['getHeaderPre']>;
    chunkFeatureCache: ChunkFeatureCache<T>;
    private RecordClass;
    constructor({ bamFilehandle, bamPath, bamUrl, baiPath, baiFilehandle, baiUrl, csiPath, csiFilehandle, csiUrl, htsget, renameRefSeqs, recordClass, maxCacheBytes, }: {
        bamFilehandle?: GenericFilehandle;
        bamPath?: string;
        bamUrl?: string;
        baiPath?: string;
        baiFilehandle?: GenericFilehandle;
        baiUrl?: string;
        csiPath?: string;
        csiFilehandle?: GenericFilehandle;
        csiUrl?: string;
        renameRefSeqs?: (a: string) => string;
        htsget?: boolean;
        recordClass?: BamRecordClass<T>;
        /** budget for the parsed-chunk cache, in decompressed bytes */
        maxCacheBytes?: number;
    });
    getHeaderPre(opts?: BaseOpts): Promise<{
        tag: string;
        data: {
            tag: string;
            value: string;
        }[];
    }[] | undefined>;
    getHeader(opts?: BaseOpts): Promise<{
        tag: string;
        data: {
            tag: string;
            value: string;
        }[];
    }[] | undefined>;
    getHeaderText(opts?: BaseOpts): Promise<string | undefined>;
    private getSeqId;
    getRecordsForRange(chr: string, min: number, max: number, opts?: BamOpts): Promise<T[]>;
    private _cachedChunkFeatures;
    private _fetchChunkFeatures;
    fetchPairs(chrId: number, records: T[], opts: BamOpts): Promise<T[]>;
    _readChunkFeatures(chunk: Chunk, opts: BaseOpts): Promise<{
        features: T[];
        bytes: number;
    }>;
    readBamFeatures(ba: Uint8Array, cpositions: number[], dpositions: number[], chunk: Chunk): T[];
    hasRefSeq(seqName: string, opts?: BaseOpts): Promise<boolean>;
    lineCount(seqName: string, opts?: BaseOpts): Promise<number>;
    indexCov(seqName: string, start?: number, end?: number): Promise<never[] | import("./bai.ts").IndexCovEntry[]>;
    blocksForRange(seqName: string, start: number, end: number, opts?: BaseOpts): Promise<Chunk[] | never[]>;
    clearFeatureCache(): void;
    estimatedBytesForRegions(regions: {
        refName: string;
        start: number;
        end: number;
    }[], opts?: BaseOpts): Promise<number>;
}
export {};