import { RedisClientType } from 'redis';

type TimeWindow = `${number} ms` | `${number} s` | `${number} m` | `${number} h` | `${number} d`;
interface FixedWindowOptions {
    interval: number;
    limit: number;
}
interface SlidingWindowOptions {
    interval: number;
    limit: number;
}
interface TokenBucketOptions {
    refillRate: number;
    interval: number;
    limit: number;
}
interface RatelimitResponse {
    success: boolean;
    limit: number;
    remaining: number;
    reset: number;
    retryAfter?: number;
    pending?: number;
    throughput?: number;
}
interface RatelimitConfig {
    redis: RedisClientType | Promise<RedisClientType>;
    limiter: LimiterType;
    prefix?: string;
    analytics?: boolean;
    timeout?: number;
    ephemeralCache?: boolean;
    ephemeralCacheTTL?: number;
}
type LimiterType = FixedWindowOptions | SlidingWindowOptions | TokenBucketOptions;

declare class Ratelimit {
    private redisPromise;
    private limiter;
    private limiterType;
    private prefix;
    private analytics;
    private timeout;
    private ephemeralCache?;
    constructor(config: RatelimitConfig);
    private getRedis;
    limit(identifier: string): Promise<RatelimitResponse>;
    private applySlidingWindowLimit;
    private applyFixedWindowLimit;
    private applyTokenBucketLimit;
    block(identifier: string, maxWaitMs?: number): Promise<RatelimitResponse>;
    reset(identifier: string): Promise<void>;
}

declare class RatelimitError extends Error {
    constructor(message: string);
}
declare const fixedWindow: (limit: number, window: TimeWindow) => FixedWindowOptions;
declare const slidingWindow: (limit: number, window: TimeWindow) => SlidingWindowOptions;
declare const tokenBucket: (refillRate: number, interval: TimeWindow, limit: number) => TokenBucketOptions;
declare const getRedisSingleClient: (envRedisKey: string) => RedisClientType;
interface CreateRateLimiterProps extends Omit<RatelimitConfig, 'redis'> {
}
declare const createSingletonRateLimiter: (props?: CreateRateLimiterProps & {
    limiter?: LimiterType;
    envRedisKey?: string;
}) => Ratelimit;
declare const createRateLimiter: (redis: RedisClientType, props?: CreateRateLimiterProps & {
    limiter?: LimiterType;
    envRedisKey?: string;
}) => Ratelimit;

export { type CreateRateLimiterProps, Ratelimit, RatelimitError, createRateLimiter, createSingletonRateLimiter, fixedWindow, getRedisSingleClient, slidingWindow, tokenBucket };