/**
 * Rate Limiter Pattern - Control request throughput
 */
import { AsyncFunction, Logger } from "../types/common";
import { RateLimitStrategy, RateLimiterOptions, RateLimitResult } from "../types/rate-limiter";
/**
 * Internal options (without execute field)
 */
interface RateLimiterInternalOptions {
    maxRequests?: number;
    windowMs?: number;
    strategy?: RateLimitStrategy;
    refillRate?: number;
    logger?: Logger;
    onLimitReached?: (retryAfter: number) => void;
}
/**
 * Sliding Window Rate Limiter
 */
declare class SlidingWindowLimiter {
    private maxRequests;
    private windowMs;
    private requests;
    constructor(maxRequests: number, windowMs: number);
    acquire(): Promise<{
        allowed: boolean;
        retryAfter: number;
        remaining: number;
    }>;
    getRemaining(): number;
    reset(): void;
}
/**
 * Fixed Window Rate Limiter
 */
declare class FixedWindowLimiter {
    private maxRequests;
    private windowMs;
    private count;
    private windowStart;
    constructor(maxRequests: number, windowMs: number);
    acquire(): Promise<{
        allowed: boolean;
        retryAfter: number;
        remaining: number;
    }>;
    getRemaining(): number;
    reset(): void;
}
/**
 * Token Bucket Rate Limiter
 */
declare class TokenBucketLimiter {
    private maxTokens;
    private refillRate;
    private tokens;
    private lastRefill;
    constructor(maxTokens: number, refillRate: number);
    acquire(): Promise<{
        allowed: boolean;
        retryAfter: number;
        remaining: number;
    }>;
    private refill;
    getRemaining(): number;
    reset(): void;
}
type Limiter = SlidingWindowLimiter | FixedWindowLimiter | TokenBucketLimiter;
/**
 * Rate Limiter - Controls request throughput
 */
export declare class RateLimiter<TResult = any, TArgs extends any[] = any[]> {
    private readonly fn;
    private readonly options;
    private limiter;
    constructor(fn: AsyncFunction<TResult, TArgs>, options?: RateLimiterInternalOptions);
    /**
     * Execute function with rate limiting
     */
    execute(...args: TArgs): Promise<RateLimitResult<TResult>>;
    /**
     * Execute with automatic wait if rate limit reached
     */
    executeWithWait(...args: TArgs): Promise<RateLimitResult<TResult>>;
    /**
     * Get remaining requests
     */
    getRemaining(): number;
    /**
     * Reset rate limiter
     */
    reset(): void;
    /**
     * Get the internal limiter for direct access (used by middleware)
     * @internal
     */
    getLimiter(): Limiter;
}
/**
 * Callable rate limiter type (Vercel-style)
 */
export interface CallableRateLimiter<TResult = any, TArgs extends any[] = any[]> {
    (...args: TArgs): Promise<RateLimitResult<TResult>>;
    wait(...args: TArgs): Promise<RateLimitResult<TResult>>;
    getRemaining(): number;
    reset(): void;
}
/**
 * Define a rate limiter with Vercel-style callable API
 *
 * @example
 * ```typescript
 * const limiter = defineRateLimiter({
 *   execute: async () => callAPI(),
 *   maxRequests: 60,
 *   windowMs: 60000
 * });
 *
 * const result = await limiter(); // Direct call
 * console.log(limiter.getRemaining()); // Check remaining
 * await limiter.wait(); // Wait if needed
 * ```
 */
export declare function defineRateLimiter<TResult = any, TArgs extends any[] = any[]>(options: RateLimiterOptions<TResult>): CallableRateLimiter<TResult, TArgs>;
/**
 * @deprecated Use `defineRateLimiter` instead for better alignment with Vercel AI SDK patterns
 * @see defineRateLimiter
 */
export declare const rateLimiter: typeof defineRateLimiter;
export {};
//# sourceMappingURL=rate-limiter.d.ts.map