/**
 * Agentic QE v3 - MCP Security: Rate Limiter
 * Token bucket algorithm implementation (ADR-012)
 *
 * Features:
 * - Token bucket rate limiting (100 req/s, 200 burst)
 * - Per-client and global rate limiting
 * - Sliding window for smooth rate limiting
 * - Configurable limits per endpoint
 */
/**
 * Rate limiter configuration
 */
export interface RateLimiterConfig {
    /** Tokens per second (refill rate) */
    tokensPerSecond: number;
    /** Maximum burst capacity */
    maxBurst: number;
    /** Enable per-client limiting */
    perClient?: boolean;
    /** Cleanup interval in ms for expired buckets */
    cleanupInterval?: number;
    /** Maximum age for inactive buckets in ms */
    maxBucketAge?: number;
}
/**
 * Token bucket state
 */
export interface TokenBucket {
    /** Current token count */
    tokens: number;
    /** Last update timestamp */
    lastUpdate: number;
    /** Total requests made */
    totalRequests: number;
    /** Requests in current window */
    windowRequests: number;
    /** Window start time */
    windowStart: number;
}
/**
 * Rate limit result
 */
export interface RateLimitResult {
    /** Whether the request is allowed */
    allowed: boolean;
    /** Remaining tokens */
    remaining: number;
    /** Time until next token in ms */
    retryAfter?: number;
    /** Current request rate */
    currentRate?: number;
    /** Limit info for headers */
    headers: RateLimitHeaders;
}
/**
 * Rate limit headers for HTTP responses
 */
export interface RateLimitHeaders {
    'X-RateLimit-Limit': number;
    'X-RateLimit-Remaining': number;
    'X-RateLimit-Reset': number;
    'Retry-After'?: number;
}
/**
 * Rate limiter statistics
 */
export interface RateLimiterStats {
    totalRequests: number;
    allowedRequests: number;
    deniedRequests: number;
    activeBuckets: number;
    averageTokens: number;
}
/**
 * Endpoint-specific rate limit configuration
 */
export interface EndpointRateLimit {
    pattern: RegExp | string;
    tokensPerSecond: number;
    maxBurst: number;
}
/**
 * Token Bucket Rate Limiter
 * Implements the token bucket algorithm for rate limiting
 */
export declare class RateLimiter {
    private readonly config;
    private readonly globalBucket;
    private readonly clientBuckets;
    private readonly endpointLimits;
    private cleanupTimer;
    private stats;
    constructor(config: RateLimiterConfig);
    /**
     * Check if a request is allowed
     */
    check(clientId?: string, endpoint?: string): RateLimitResult;
    /**
     * Consume tokens (blocks if not available in sync mode)
     */
    consume(clientId?: string, endpoint?: string, tokens?: number): RateLimitResult;
    /**
     * Wait until tokens are available (async)
     */
    wait(clientId?: string, endpoint?: string, tokens?: number): Promise<RateLimitResult>;
    /**
     * Add endpoint-specific rate limit
     */
    addEndpointLimit(limit: EndpointRateLimit): void;
    /**
     * Remove all endpoint limits
     */
    clearEndpointLimits(): void;
    /**
     * Reset a client's bucket
     */
    resetClient(clientId: string): void;
    /**
     * Reset all buckets
     */
    reset(): void;
    /**
     * Get rate limiter statistics
     */
    getStats(): RateLimiterStats;
    /**
     * Get client-specific statistics
     */
    getClientStats(clientId: string): TokenBucket | null;
    /**
     * Dispose the rate limiter
     */
    dispose(): void;
    private createBucket;
    private getBucket;
    private getEndpointKey;
    private getConfig;
    private refillBucket;
    private buildHeaders;
    private calculateRate;
    private startCleanup;
    private cleanup;
    private sleep;
}
/**
 * Sliding window log for more accurate rate limiting
 */
export interface SlidingWindowEntry {
    timestamp: number;
    weight: number;
}
/**
 * Sliding Window Rate Limiter
 * More accurate but uses more memory
 */
export declare class SlidingWindowRateLimiter {
    private readonly windowMs;
    private readonly maxRequests;
    private readonly windows;
    private readonly cleanupInterval;
    constructor(windowMs?: number, maxRequests?: number);
    check(clientId: string): RateLimitResult;
    reset(clientId?: string): void;
    dispose(): void;
    private getEntries;
    private cleanup;
}
/**
 * Create a new rate limiter with default configuration
 * Default: 100 requests/second, 200 burst capacity
 */
export declare function createRateLimiter(config?: Partial<RateLimiterConfig>): RateLimiter;
/**
 * Create a strict rate limiter for sensitive endpoints
 * Default: 10 requests/second, 20 burst capacity
 */
export declare function createStrictRateLimiter(config?: Partial<RateLimiterConfig>): RateLimiter;
/**
 * Create a sliding window rate limiter
 */
export declare function createSlidingWindowLimiter(windowMs?: number, maxRequests?: number): SlidingWindowRateLimiter;
/**
 * Get the default rate limiter instance
 */
export declare function getRateLimiter(): RateLimiter;
/**
 * Reset the default rate limiter
 */
export declare function resetDefaultRateLimiter(): void;
//# sourceMappingURL=rate-limiter.d.ts.map