/**
 * RATE LIMITER - Token bucket & sliding window algorithms
 * Per-user, per-model, and global quotas with Redis backend
 */
export declare enum RateLimitAlgorithm {
    TOKEN_BUCKET = "token_bucket",
    SLIDING_WINDOW = "sliding_window",
    FIXED_WINDOW = "fixed_window",
    LEAKY_BUCKET = "leaky_bucket"
}
export interface RateLimitConfig {
    algorithm: RateLimitAlgorithm;
    max_requests: number;
    window_ms: number;
    bucket_size?: number;
    refill_rate?: number;
    redis_url?: string;
    redis_key_prefix?: string;
}
export interface RateLimitResult {
    allowed: boolean;
    limit: number;
    remaining: number;
    reset_at: Date;
    retry_after_ms?: number;
}
export interface RateLimitQuota {
    user_id?: string;
    model?: string;
    scope: 'user' | 'model' | 'global' | 'user-model';
    max_requests: number;
    window_ms: number;
}
export interface RateLimitStats {
    total_requests: number;
    allowed_requests: number;
    blocked_requests: number;
    current_usage: number;
    quota_limit: number;
    reset_at: Date;
}
export declare class TokenBucketLimiter {
    private capacity;
    private refill_rate;
    private tokens;
    private last_refill;
    private total_requests;
    private blocked_requests;
    constructor(capacity: number, refill_rate: number);
    /**
     * Try to consume tokens
     */
    consume(tokens?: number): RateLimitResult;
    /**
     * Get current stats
     */
    getStats(): RateLimitStats;
    /**
     * Reset the bucket
     */
    reset(): void;
    private refillTokens;
    private getResetTime;
}
export declare class SlidingWindowLimiter {
    private max_requests;
    private window_ms;
    private requests;
    private total_requests;
    private blocked_requests;
    constructor(max_requests: number, window_ms: number);
    /**
     * Check if request is allowed
     */
    checkLimit(): RateLimitResult;
    /**
     * Get current stats
     */
    getStats(): RateLimitStats;
    /**
     * Reset the limiter
     */
    reset(): void;
    private cleanOldRequests;
    private getResetTime;
}
export declare class FixedWindowLimiter {
    private max_requests;
    private window_ms;
    private current_window_start;
    private request_count;
    private total_requests;
    private blocked_requests;
    constructor(max_requests: number, window_ms: number);
    /**
     * Check if request is allowed
     */
    checkLimit(): RateLimitResult;
    /**
     * Get current stats
     */
    getStats(): RateLimitStats;
    /**
     * Reset the limiter
     */
    reset(): void;
    private maybeResetWindow;
    private getResetTime;
}
export declare class LeakyBucketLimiter {
    private capacity;
    private leak_rate;
    private queue;
    private last_leak;
    private total_requests;
    private blocked_requests;
    constructor(capacity: number, leak_rate: number);
    /**
     * Try to add request to bucket
     */
    checkLimit(): RateLimitResult;
    /**
     * Get current stats
     */
    getStats(): RateLimitStats;
    /**
     * Reset the limiter
     */
    reset(): void;
    private leak;
    private getResetTime;
}
export declare class RateLimiter {
    private limiters;
    private config;
    constructor(config: RateLimitConfig);
    /**
     * Check rate limit for a key
     */
    checkLimit(key: string): RateLimitResult;
    /**
     * Check rate limit with quota
     */
    checkQuota(quota: RateLimitQuota): RateLimitResult;
    /**
     * Get stats for a key
     */
    getStats(key: string): RateLimitStats | null;
    /**
     * Reset limiter for a key
     */
    reset(key: string): void;
    /**
     * Reset all limiters
     */
    resetAll(): void;
    /**
     * Get all active keys
     */
    getActiveKeys(): string[];
    private createLimiter;
    private getQuotaKey;
}
export declare class RateLimitManager {
    private user_config?;
    private model_config?;
    private global_limiter;
    private user_limiters;
    private model_limiters;
    private user_model_limiters;
    constructor(_global_config: RateLimitConfig, user_config?: RateLimitConfig | undefined, model_config?: RateLimitConfig | undefined);
    /**
     * Check all applicable rate limits
     */
    checkLimits(params: {
        user_id?: string;
        model?: string;
    }): RateLimitResult;
    /**
     * Get stats for all limiters
     */
    getStats(params: {
        user_id?: string;
        model?: string;
    }): {
        global?: RateLimitStats;
        user?: RateLimitStats;
        model?: RateLimitStats;
        user_model?: RateLimitStats;
    };
    /**
     * Reset all limiters
     */
    resetAll(): void;
    private getUserLimiter;
    private getModelLimiter;
    private getUserModelLimiter;
}
export declare class RateLimitExceededError extends Error {
    readonly retry_after_ms: number;
    readonly limit: number;
    readonly reset_at: Date;
    constructor(message: string, result: RateLimitResult);
}
//# sourceMappingURL=rate-limiter.d.ts.map