export interface RateLimitContext {
    key: string;
    ip?: string;
    userId?: string;
    userPlan?: string;
    endpoint?: string;
    method?: string;
    path?: string;
    headers?: Record<string, string | string[] | undefined>;
    metadata?: Record<string, unknown>;
    [key: string]: unknown;
}
export interface RateLimitCheckOptions {
    points?: number;
    context?: RateLimitContext;
}
export interface RateLimitResult {
    allowed: boolean;
    limit: number;
    remaining: number;
    reset: number;
    retryAfter?: number;
    appliedRuleId?: string;
    context?: RateLimitContext;
}
export interface RateLimitConfig {
    windowSize: number;
    maxRequests: number;
    keyPrefix?: string;
    skipSuccessfulRequests?: boolean;
    skipFailedRequests?: boolean;
    requestWasSuccessful?: (statusCode?: number) => boolean;
    onLimitReached?: (key: string, result: RateLimitResult, context?: RateLimitContext) => void | Promise<void>;
}
export interface RateLimiter {
    check(key: string, options?: RateLimitCheckOptions): Promise<RateLimitResult>;
    reset(key: string, context?: RateLimitContext): Promise<boolean>;
    setLimit(key: string, limit: number, context?: RateLimitContext): Promise<boolean>;
    getLimit(key: string, context?: RateLimitContext): Promise<number | null>;
    getUsage(key: string, context?: RateLimitContext): Promise<{
        used: number;
        remaining: number;
        reset: number;
    } | null>;
}
export interface RateLimitStorage {
    get(key: string): Promise<RateLimitData | null>;
    set(key: string, data: RateLimitData, ttl?: number): Promise<boolean>;
    increment(key: string, amount?: number): Promise<number>;
    delete(key: string): Promise<boolean>;
    exists(key: string): Promise<boolean>;
    expire(key: string, ttl: number): Promise<boolean>;
    multi(): RateLimitTransaction;
}
export interface RateLimitTransaction {
    get(key: string): this;
    set(key: string, data: RateLimitData, ttl?: number): this;
    increment(key: string, amount?: number): this;
    delete(key: string): this;
    expire(key: string, ttl: number): this;
    exec(): Promise<any[]>;
}
export interface RateLimitData {
    count: number;
    resetTime: number;
    window?: number;
    tokens?: number;
    lastRefill?: number;
}
export interface TokenBucketConfig extends RateLimitConfig {
    bucketSize: number;
    refillRate: number;
    tokensPerRequest?: number;
}
export interface SlidingWindowConfig extends RateLimitConfig {
    precision?: number;
}
export interface FixedWindowConfig extends RateLimitConfig {
}
export interface LeakyBucketConfig extends RateLimitConfig {
    bucketSize: number;
    leakRate: number;
}
export type RateLimitAlgorithm = 'token-bucket' | 'sliding-window' | 'fixed-window' | 'leaky-bucket';
export interface RateLimiterOptions {
    algorithm: RateLimitAlgorithm;
    config: RateLimitConfig;
    storage: RateLimitStorage;
}
export interface RateLimitRule {
    id?: string;
    description?: string;
    priority?: number;
    algorithm?: RateLimitAlgorithm;
    limit?: number;
    windowMs?: number;
    bucketSize?: number;
    refillRate?: number;
    tokensPerRequest?: number;
    precision?: number;
    leakRate?: number;
    keyPrefix?: string;
    onLimitReached?: (key: string, result: RateLimitResult, context?: RateLimitContext) => void | Promise<void>;
    match: (context: RateLimitContext) => boolean | Promise<boolean>;
}
export interface CreateRateLimiterOptions {
    algorithm?: RateLimitAlgorithm;
    limit: number;
    windowMs: number;
    bucketSize?: number;
    refillRate?: number;
    tokensPerRequest?: number;
    precision?: number;
    leakRate?: number;
    keyPrefix?: string;
    storage?: RateLimitStorage | RateLimitStorageOptions;
    skipOnError?: boolean;
    onLimitReached?: (key: string, result: RateLimitResult, context?: RateLimitContext) => void | Promise<void>;
    customRules?: RateLimitRule[];
}
export type RateLimitStorageOptions = 'memory' | {
    type: 'memory';
    cleanupIntervalMs?: number;
} | {
    type: 'redis';
    client: unknown;
    keyPrefix?: string;
} | {
    type: 'ioredis';
    client: unknown;
    keyPrefix?: string;
} | {
    type: 'database';
    adapter: RateLimitDatabaseAdapter;
    keyPrefix?: string;
};
export interface RateLimitDatabaseAdapter {
    get(key: string): Promise<RateLimitData | null>;
    set(key: string, data: RateLimitData, ttl?: number): Promise<void>;
    increment(key: string, amount?: number): Promise<number>;
    delete(key: string): Promise<void>;
    expire(key: string, ttl: number): Promise<void>;
}
export interface MiddlewareOptions {
    keyGenerator?: (req: any) => string | Promise<string>;
    skip?: (req: any) => boolean | Promise<boolean>;
    handler?: (req: any, res: any, result: RateLimitResult) => void | Promise<void>;
    standardHeaders?: boolean;
    legacyHeaders?: boolean;
    requestPropertyName?: string;
    points?: number | ((req: any) => number | Promise<number>);
    contextBuilder?: (req: any) => RateLimitContext | Promise<RateLimitContext>;
}
export interface RateLimitHeaders {
    'X-RateLimit-Limit'?: number;
    'X-RateLimit-Remaining'?: number;
    'X-RateLimit-Reset'?: number;
    'X-Rate-Limit-Limit'?: number;
    'X-Rate-Limit-Remaining'?: number;
    'X-Rate-Limit-Reset'?: number;
    'Retry-After'?: number;
}