ts-rate-limiter/dist/types.d.ts

High-performance, flexible rate limiting for TypeScript and Bun

export declare interface RateLimiterConfig {
  verbose: boolean

  storage?: 'memory' | 'redis'

  algorithm?: 'fixed-window' | 'sliding-window' | 'token-bucket'

  windowMs?: number

  maxRequests?: number

  redisKeyPrefix?: string

  standardHeaders?: boolean

  legacyHeaders?: boolean

  draftMode?: boolean

  memoryStorage?: {
    enableAutoCleanup?: boolean
    cleanupIntervalMs?: number
  }

  redis?: {
    url?: string
    enableSlidingWindow?: boolean
  }
}
export declare interface StorageProvider {
  increment: (key: string, windowMs: number) => Promise<{
    count: number
    resetTime: number
  }>

  reset: (key: string) => Promise<void>

  getCount?: (key: string) => Promise<number>

  getSlidingWindowCount?: (key: string, windowMs: number) => Promise<number>

  batchIncrement?: (keys: string[], windowMs: number) => Promise<Map<string, { count: number, resetTime: number }>>

  cleanExpired?: () => void

  dispose?: () => void
}
export declare type RateLimitAlgorithm = 'fixed-window' | 'sliding-window' | 'token-bucket'

export interface RateLimiterOptions {
  windowMs: number

  maxRequests: number

  storage?: StorageProvider

  keyGenerator?: (request: Request) => string | Promise<string>

  skipFailedRequests?: boolean

  algorithm?: RateLimitAlgorithm

  standardHeaders?: boolean

  legacyHeaders?: boolean

  skip?: (request: Request) => boolean | Promise<boolean>

  handler?: (request: Request, result: RateLimitResult) => Response | Promise<Response>

  draftMode?: boolean
}

export interface RateLimitResult {
  allowed: boolean

  current: number

  limit: number

  remaining: number

  resetTime: number
}

export interface TokenBucketOptions {
  capacity: number

  refillRate: number
}

export interface RedisStorageOptions {
  client: any

  keyPrefix?: string

  enableSlidingWindow?: boolean
}

export interface MemoryStorageOptions {
  enableAutoCleanup?: boolean

  cleanupIntervalMs?: number
}