import { SingleFlight } from '@logosdx/utils';
import type { _InternalHttpMethods, CacheRule, CacheConfig, RequestSerializer, CacheAdapter, RequestKeyOptions } from '../types.ts';
import type { FetchPlugin } from '../engine/types.ts';
import { ResiliencePolicy } from './base.ts';
/**
 * Extended internal state for cache policy.
 * Includes SWR tracking sets for background revalidation.
 */
export interface CachePolicyState<S, H, P> {
    /** Whether the policy is globally enabled */
    enabled: boolean;
    /** Set of HTTP methods this policy applies to */
    methods: Set<string>;
    /** The serializer function for key generation */
    serializer: RequestSerializer<S, H, P>;
    /** Memoized rule cache: method:path -> resolved rule or null */
    rulesCache: Map<string, CacheRule<S, H, P> | null>;
    /** Default TTL in milliseconds */
    ttl: number;
    /** Default stale time for SWR in milliseconds */
    staleIn: number | undefined;
    /** Keys currently being fetched (for SWR deduplication) */
    activeKeys: Set<string>;
    /** Keys currently being revalidated in background */
    revalidatingKeys: Set<string>;
}
/**
 * Cache policy for storing and retrieving response data.
 *
 * Supports stale-while-revalidate (SWR) pattern where stale cached data
 * is returned immediately while fresh data is fetched in the background.
 *
 * @template S - Instance state type
 * @template H - Headers type
 * @template P - Params type
 */
export declare class CachePolicy<S = unknown, H = unknown, P = unknown> extends ResiliencePolicy<CacheConfig<S, H, P>, CacheRule<S, H, P>, S, H, P> {
    /**
     * Extended state with cache-specific fields.
     */
    protected state: CachePolicyState<S, H, P> | null;
    /**
     * Get the cache adapter (if configured).
     */
    get adapter(): CacheAdapter<unknown> | undefined;
    /**
     * Get active keys set (for SWR tracking).
     */
    get activeKeys(): Set<string>;
    /**
     * Get revalidating keys set (for SWR tracking).
     */
    get revalidatingKeys(): Set<string>;
    /**
     * Get the default TTL.
     */
    get defaultTtl(): number;
    /**
     * Get the default stale time for SWR.
     */
    get defaultStaleIn(): number | undefined;
    /**
     * Get the default serializer for caching.
     */
    protected getDefaultSerializer(): RequestSerializer<S, H, P>;
    /**
     * Get the default HTTP methods for caching.
     */
    protected getDefaultMethods(): _InternalHttpMethods[];
    /**
     * Initialize the cache policy with configuration.
     */
    init(config?: boolean | CacheConfig<S, H, P>): void;
    /**
     * Merge a matched rule with policy defaults.
     */
    protected mergeRuleWithDefaults(rule: CacheRule<S, H, P> | null): CacheRule<S, H, P>;
    /**
     * Resolve cache configuration for a request.
     */
    resolveForRequest(method: string, path: string, ctx: RequestKeyOptions<S, H, P>): CacheRule<S, H, P> | null;
    /**
     * Mark a key as actively being fetched.
     */
    markActive(key: string): void;
    /**
     * Unmark a key as actively being fetched.
     */
    unmarkActive(key: string): void;
    /**
     * Check if a key is currently being revalidated.
     */
    isRevalidating(key: string): boolean;
    /**
     * Mark a key as being revalidated in background.
     */
    markRevalidating(key: string): void;
    /**
     * Unmark a key as being revalidated.
     */
    unmarkRevalidating(key: string): void;
    /**
     * Clear all active keys.
     */
    clearActiveKeys(): void;
    /**
     * Get all active cache keys.
     */
    getActiveKeys(): string[];
}
/**
 * Factory function that creates a cache plugin for FetchEngine.
 *
 * The plugin creates its own `SingleFlight` for cache storage and installs
 * `beforeRequest` (priority -20) and `afterRequest` (priority -10) hooks.
 *
 * @param config - Cache configuration
 * @returns Object with FetchPlugin interface plus cache management methods
 *
 * @example
 *     const cache = cachePlugin({ ttl: 300000, staleIn: 60000 });
 *     const api = new FetchEngine({
 *         baseUrl: 'https://api.example.com',
 *         plugins: [cache]
 *     });
 *
 *     // Access cache methods directly on the plugin
 *     cache.clearCache();
 *     cache.stats();
 */
export declare function cachePlugin<H = unknown, P = unknown, S = unknown>(config: boolean | CacheConfig<S, H, P>): FetchPlugin<H, P, S> & {
    policy: CachePolicy<S, H, P>;
    flight: SingleFlight<unknown>;
    clearCache(): void;
    clearCacheKey(key: string): Promise<boolean>;
    deleteCache(key: string): Promise<boolean>;
    invalidateCache(predicate: (key: string) => boolean): Promise<number>;
    invalidatePath(pattern: string | RegExp | ((key: string) => boolean)): Promise<number>;
    stats(): {
        cacheSize: number;
        inflightCount: number;
    };
};