import type { CacheBackend, CacheReadOptions } from "../types.js";
import { type ResolvedCacheAuthority } from "../request-authority.js";
export declare class ApiCacheBackend implements CacheBackend {
    readonly type: "api";
    private apiBaseUrl;
    private readonly apiOrigin;
    private readonly hasExplicitApiBaseUrl;
    private readonly explicitApiToken?;
    private keyPrefix;
    private timeoutMs;
    private readonly maxResponseBytes;
    private circuitBreaker;
    constructor(options?: {
        apiBaseUrl?: string;
        /** Credential paired with a caller-selected apiBaseUrl. */
        apiToken?: string;
        keyPrefix?: string;
        timeoutMs?: number;
        maxResponseBytes?: number;
        circuitBreakerName?: string;
    });
    /**
     * The authority every read through this backend is gated on. Exposed so the
     * process-local file-cache tier scopes what it holds on this backend's own
     * resolution, including a caller-selected endpoint credential, rather than
     * re-deriving the ambient one and drifting from the gate it sits in front of.
     */
    cacheAuthority(): ResolvedCacheAuthority;
    private prefixKey;
    private request;
    get(key: string, options?: CacheReadOptions): Promise<string | null>;
    getWithinLimit(key: string, maximumBytes: number): Promise<string | null>;
    getBatch(keys: string[], options?: CacheReadOptions): Promise<Map<string, string | null>>;
    private getIndividually;
    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
    setBatch(entries: Array<{
        key: string;
        value: string;
        ttl?: number;
    }>): Promise<void>;
    del(key: string): Promise<void>;
    delByPattern(pattern: string): Promise<number>;
}
//# sourceMappingURL=api.d.ts.map