/**
 * Request Deduplication
 *
 * Prevents duplicate concurrent API requests by caching in-flight
 * requests and returning the same promise for identical requests.
 *
 * @module api/advanced/request-deduplication
 */
/**
 * Deduplication configuration.
 */
export interface DeduplicationConfig {
    /** How to generate cache keys */
    keyGenerator?: (request: DeduplicationRequest) => string;
    /** Time-to-live for cached promises (ms) */
    ttl?: number;
    /** Maximum number of cached entries */
    maxSize?: number;
    /** Whether to dedupe mutations (POST/PUT/PATCH/DELETE) */
    dedupeMutations?: boolean;
    /** Enable debug logging */
    debug?: boolean;
}
/**
 * Request to potentially deduplicate.
 */
export interface DeduplicationRequest {
    /** Request URL */
    url: string;
    /** HTTP method */
    method: string;
    /** Request body */
    body?: unknown;
    /** Request headers */
    headers?: Record<string, string>;
}
/**
 * Deduplication statistics.
 */
export interface DeduplicationStats {
    /** Total requests processed */
    totalRequests: number;
    /** Requests that were deduplicated */
    deduplicatedRequests: number;
    /** Current cache size */
    cacheSize: number;
    /** Cache hit rate */
    hitRate: number;
    /** Average subscribers per deduplicated request */
    avgSubscribers: number;
}
/**
 * Request Deduplicator for preventing duplicate concurrent requests.
 *
 * @example
 * ```typescript
 * const dedup = new RequestDeduplicator({
 *   ttl: 5000,
 *   maxSize: 100,
 * });
 *
 * // Multiple calls with same request will share one actual fetch
 * const [result1, result2, result3] = await Promise.all([
 *   dedup.dedupe({ url: '/users', method: 'GET' }, () => fetch('/api/users')),
 *   dedup.dedupe({ url: '/users', method: 'GET' }, () => fetch('/api/users')),
 *   dedup.dedupe({ url: '/users', method: 'GET' }, () => fetch('/api/users')),
 * ]);
 * // Only one fetch was actually made!
 * ```
 */
export declare class RequestDeduplicator {
    private config;
    private cache;
    private stats;
    /**
     * Create a new request deduplicator.
     *
     * @param config - Deduplication configuration
     */
    constructor(config?: DeduplicationConfig);
    /**
     * Deduplicate a request.
     *
     * @param request - Request to potentially deduplicate
     * @param executor - Function to execute if not deduplicated
     * @returns Promise resolving to the result
     */
    dedupe<T>(request: DeduplicationRequest, executor: () => Promise<T>): Promise<T>;
    /**
     * Check if a request is currently in flight.
     *
     * @param request - Request to check
     * @returns Whether request is in flight
     */
    isInFlight(request: DeduplicationRequest): boolean;
    /**
     * Cancel a pending request.
     *
     * @param request - Request to cancel
     * @returns Whether request was found and cancelled
     */
    cancel(request: DeduplicationRequest): boolean;
    /**
     * Clear all cached requests.
     */
    clear(): void;
    /**
     * Get deduplication statistics.
     */
    getStats(): DeduplicationStats;
    /**
     * Reset statistics.
     */
    resetStats(): void;
    /**
     * Check if request should be deduplicated.
     */
    private shouldDedupe;
    /**
     * Execute request and clean up cache.
     */
    private executeAndCleanup;
    /**
     * Check if cache entry is still valid.
     */
    private isValid;
    /**
     * Enforce maximum cache size.
     */
    private enforceMaxSize;
    /**
     * Default key generator.
     */
    private defaultKeyGenerator;
    /**
     * Hash request body for cache key.
     */
    private hashBody;
    /**
     * Log debug message.
     */
    private log;
}
/**
 * Create a new request deduplicator.
 *
 * @param config - Deduplication configuration
 * @returns RequestDeduplicator instance
 */
export declare function createRequestDeduplicator(config?: DeduplicationConfig): RequestDeduplicator;
/**
 * Create a deduplicated fetch wrapper.
 *
 * @param config - Deduplication configuration
 * @returns Wrapped fetch function
 */
export declare function createDeduplicatedFetch(config?: DeduplicationConfig): typeof fetch;
/**
 * Higher-order function to deduplicate any async function.
 *
 * @param fn - Function to deduplicate
 * @param keyGenerator - Function to generate cache key from arguments
 * @param _config
 * @returns Deduplicated function
 */
export declare function deduplicateFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, keyGenerator: (...args: TArgs) => string, _config?: Omit<DeduplicationConfig, 'keyGenerator'>): (...args: TArgs) => Promise<TResult>;
/**
 * Request deduplication for React Query or SWR integration.
 */
export declare class ReactQueryDeduplicator extends RequestDeduplicator {
    /**
     * Create a query function with deduplication.
     */
    createQueryFn<T>(queryKey: unknown[], fetcher: () => Promise<T>): () => Promise<T>;
}
/**
 * Create a React Query compatible deduplicator.
 */
export declare function createReactQueryDeduplicator(config?: DeduplicationConfig): ReactQueryDeduplicator;