interface Result {
    headers: Headers;
    buffer: Uint8Array;
}
interface Req {
    start: number;
    end: number;
    reject: (arg: unknown) => void;
    resolve: (arg: Result) => void;
    requestOptions: {
        signal?: AbortSignal;
    };
}
interface ReqGroup {
    requests: Req[];
    url: string;
    start: number;
    end: number;
}
/**
 * takes fetch requests and aggregates them at a certain time frequency
 */
export default class AggregatingFetcher {
    timeout: unknown;
    requestQueues: Record<string, Req[]>;
    fetchCallback: (url: string, start: number, end: number, arg: {
        signal?: AbortSignal;
    }) => Promise<Result>;
    frequency: number;
    maxExtraSize: number;
    maxFetchSize: number;
    /**
     *
     * @param params
     * @param [params.frequency] number of milliseconds to wait for requests to aggregate
     */
    constructor({ fetch, frequency, maxExtraSize, maxFetchSize, }: {
        fetch: (url: string, start: number, end: number) => Promise<Result>;
        frequency: number;
        maxExtraSize: number;
        maxFetchSize: number;
    });
    _canAggregate(requestGroup: ReqGroup, request: Req): boolean;
    _allSignalsFired(signals: AbortSignal[]): Promise<void>;
    _dispatch({ url, start, end, requests }: ReqGroup): void;
    _aggregateAndDispatch(): void;
    _enQueue(url: string, request: Req): void;
    /**
     *
     * @param url
     * @param start 0-based half-open
     * @param end 0-based half-open
     * @param [requestOptions] options passed to the underlying fetch call
     */
    fetch(url: string, start: number, end: number, requestOptions?: {}): Promise<unknown>;
}
export {};