/**
 * @file Request Queue
 * @description Enterprise-grade request queue with batching, rate limiting,
 * priority queuing, and deduplication
 */
/**
 * Request priority levels
 */
export type RequestPriority = 'low' | 'normal' | 'high' | 'critical';
/**
 * Request queue configuration
 */
export interface RequestQueueConfig {
    /** Maximum concurrent requests */
    concurrency?: number;
    /** Maximum queue size */
    maxQueueSize?: number;
    /** Default priority */
    defaultPriority?: RequestPriority;
    /** Default max retries */
    maxRetries?: number;
    /** Retry delay (ms) */
    retryDelay?: number;
    /** Request timeout (ms) */
    timeout?: number;
    /** Enable deduplication */
    deduplication?: boolean;
}
/**
 * Request queue for managing concurrent requests
 */
export declare class RequestQueue {
    private queue;
    private processing;
    private semaphore;
    private config;
    private dedupMap;
    private paused;
    constructor(config?: RequestQueueConfig);
    /**
     * Add request to queue
     */
    enqueue<T>(execute: () => Promise<T>, options?: {
        priority?: RequestPriority;
        maxRetries?: number;
        timeout?: number;
        dedupKey?: string;
        id?: string;
    }): Promise<T>;
    /**
     * Pause queue processing
     */
    pause(): void;
    /**
     * Resume queue processing
     */
    resume(): void;
    /**
     * Clear queue
     */
    clear(error?: Error): void;
    /**
     * Get queue statistics
     */
    getStats(): {
        queued: number;
        processing: number;
        maxConcurrency: number;
        paused: boolean;
    };
    /**
     * Remove item from queue by id
     */
    remove(id: string): boolean;
    /**
     * Insert item by priority
     */
    private insertByPriority;
    /**
     * Process queue
     */
    private process;
    /**
     * Process single item
     */
    private processItem;
    /**
     * Execute with timeout
     */
    private executeWithTimeout;
}
/**
 * Rate limiter configuration
 */
export interface RateLimiterConfig {
    /** Maximum requests per window */
    maxRequests: number;
    /** Window duration (ms) */
    windowMs: number;
    /** Strategy when limit reached */
    strategy?: 'queue' | 'reject' | 'delay';
    /** Maximum queue size (for queue strategy) */
    maxQueueSize?: number;
}
/**
 * Rate limiter for controlling request rate
 */
export declare class RateLimiter {
    private requests;
    private config;
    private queue;
    constructor(config: RateLimiterConfig);
    /**
     * Acquire rate limit slot
     */
    acquire(): Promise<() => void>;
    /**
     * Execute with rate limiting
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
    /**
     * Get rate limit status
     */
    getStatus(): {
        remaining: number;
        limit: number;
        resetMs: number;
        queued: number;
    };
    /**
     * Clear rate limit
     */
    clear(): void;
    /**
     * Check if request is allowed
     */
    private isAllowed;
    /**
     * Clean requests outside window
     */
    private cleanOldRequests;
    /**
     * Get time until next available slot
     */
    private getWaitTime;
    /**
     * Process queued requests
     */
    private processQueue;
}
/**
 * Rate limit error
 */
export declare class RateLimitError extends Error {
    readonly isRateLimitError = true;
    readonly retryAfterMs: number;
    constructor(message: string, retryAfterMs: number);
}
/**
 * Request batcher configuration
 */
export interface BatcherConfig<K, V> {
    /** Maximum batch size */
    maxBatchSize?: number;
    /** Maximum wait time (ms) */
    maxWaitMs?: number;
    /** Batch executor */
    batchFn: (keys: K[]) => Promise<Map<K, V> | V[]>;
}
/**
 * Request batcher for combining multiple requests
 */
export declare class RequestBatcher<K, V> {
    private batch;
    private timer;
    private config;
    constructor(config: BatcherConfig<K, V>);
    /**
     * Load a single item
     */
    load(key: K): Promise<V>;
    /**
     * Load multiple items
     */
    loadMany(keys: K[]): Promise<(V | Error)[]>;
    /**
     * Clear pending batch
     */
    clear(): void;
    /**
     * Get pending count
     */
    getPendingCount(): number;
    /**
     * Schedule batch execution
     */
    private scheduleBatch;
    /**
     * Execute batch
     */
    private executeBatch;
}
/**
 * Create a global request queue instance
 */
export declare const globalRequestQueue: RequestQueue;
/**
 * Create a rate limiter with common presets
 */
export declare const rateLimiters: {
    /** Standard API rate limiter (100 req/min) */
    standard: () => RateLimiter;
    /** Burst rate limiter (10 req/sec) */
    burst: () => RateLimiter;
    /** Strict rate limiter (1 req/sec) */
    strict: () => RateLimiter;
    /** Custom rate limiter */
    custom: (maxRequests: number, windowMs: number, strategy?: RateLimiterConfig["strategy"]) => RateLimiter;
};