import type { CreateVerifiedFetchOptions, Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js';
import type { Helia } from '@helia/interface';
export declare class VerifiedFetch {
    private readonly helia;
    private readonly ipnsResolver;
    private readonly dnsLink;
    private readonly log;
    private readonly contentTypeParser;
    private readonly blockstoreSessions;
    private readonly withServerTiming;
    private readonly plugins;
    constructor(helia: Helia, init?: CreateVerifiedFetchOptions);
    private getBlockstore;
    /**
     * The last place a Response touches in verified-fetch before being returned to the user. This is where we add the
     * Server-Timing header to the response if it has been collected. It should be used for any final processing of the
     * response before it is returned to the user.
     */
    private handleFinalResponse;
    /**
     * Runs plugins in a loop. After each plugin that returns `null` (partial/no final),
     * we re-check `canHandle()` for all plugins in the next iteration if the context changed.
     */
    private runPluginPipeline;
    /**
     * We're starting to get to the point where we need a queue or pipeline of
     * operations to perform and a single place to handle errors.
     *
     * TODO: move operations called by fetch to a queue of operations where we can
     * always exit early (and cleanly) if a given signal is aborted
     */
    fetch(resource: Resource, opts?: VerifiedFetchOptions): Promise<Response>;
    /**
     * Start the Helia instance
     */
    start(): Promise<void>;
    /**
     * Shut down the Helia instance
     */
    stop(): Promise<void>;
}
//# sourceMappingURL=verified-fetch.d.ts.map