import type { PathSpec } from '../../types.ts';
export interface FileCache {
    get(key: string): Promise<Uint8Array | null>;
    set(key: string, data: Uint8Array, options?: {
        fingerprint?: string | null;
        ttl?: number | null;
    }): Promise<void>;
    add(key: string, data: Uint8Array, options?: {
        fingerprint?: string | null;
        ttl?: number | null;
    }): Promise<boolean>;
    remove(key: string): Promise<void>;
    evictPrefix(prefix: string): Promise<void>;
    /**
     * Drop the given keys, synchronously.
     *
     * The load-time counterpart to {@link FileCache.remove}: `fromState`
     * is sync, so it cannot await a per-path removal — and a fire-and-
     * forget `void remove(...)` would let a read issued right after load
     * be served the very snapshot bytes the caller asked to bypass (and
     * would surface a rejection as an unhandled one). Stores whose state
     * cannot be mutated synchronously (redis) implement this as a
     * documented no-op. Mirrors Python `FileCacheMixin.evict_paths`.
     */
    evictPaths(paths: Iterable<string>): void;
    exists(key: string | PathSpec): Promise<boolean>;
    isFresh(key: string, remoteFingerprint: string): Promise<boolean>;
    clear(): Promise<void>;
    multiGet(keys: readonly string[]): Promise<(Uint8Array | null)[]>;
    readonly cacheSize: number | null;
    readonly cacheEntries?: number | null;
    readonly cacheLimit: number;
    maxDrainBytes: number | null;
    readonly drainTasks?: Map<string, Promise<void>>;
}
/**
 * Max bytes a background drain may buffer to fill the cache.
 *
 * null (the default) derives the budget from `cacheLimit`. An explicit
 * value limits speculative background reads further and may not exceed
 * the cache's intended capacity. Mirrors Python `drain_budget`.
 */
export declare function drainBudget(cache: FileCache): number;
export declare function validateMaxDrainBytes(cacheLimit: number, maxDrainBytes: number | null): void;
//# sourceMappingURL=mixin.d.ts.map