@ratelock/redis/dist/index-BjDJD-vj.d.cts

Redis storage backend for RateLock rate limiting system

import { FixedWindowStrategy, IndividualFixedWindowStrategy, InferStrategyResult, SlidingWindowLimited, SlidingWindowStrategy, TokenBasedLimited, TokenBucketStrategy, WindowedLimited } from "@ratelock/core/strategy";

//#region src/strategy/fixed-window/index.d.ts

/**
 * Redis-backed Fixed Window Rate Limiting Strategy
 * Uses Lua scripting for atomic operations and improved performance
 */
declare class FixedWindowStrategy$1 extends FixedWindowStrategy {
  private scriptSha;
  /**
   * Checks if a request is allowed under the current rate limit
   * @param identifier - Unique identifier for the rate limit window
   * @returns Promise containing rate limit result with:
   *          - allowed: boolean indicating if request is permitted
   *          - remaining: number of remaining requests in window
   *          - reset: timestamp when window resets
   */
  check(identifier: string): Promise<InferStrategyResult<WindowedLimited>>;
}
/**
 * Factory function for creating FixedWindowStrategy instances
 * @param storage - Redis storage implementation
 * @param options - Fixed window configuration options
 * @returns New FixedWindowStrategy instance
 */
declare const createFixedWindowStrategy: any;
//#endregion
//#region src/strategy/individual-fixed-window/index.d.ts
/**
 * Individual Fixed Window Rate Limiting Strategy
 * Uses Redis Lua scripting for atomic operations with per-identifier windows
 * that start at first request rather than global time intervals
 */
declare class IndividualFixedWindowStrategy$1 extends IndividualFixedWindowStrategy {
  private scriptSha;
  /**
   * Checks if a request is allowed under the individual fixed window rate limit
   * @param identifier - Unique identifier for the rate limit window
   * @returns Promise containing rate limit result with:
   *          - allowed: boolean indicating if request is permitted
   *          - remaining: number of remaining requests in window
   *          - reset: timestamp when window resets
   */
  check(identifier: string): Promise<InferStrategyResult<WindowedLimited>>;
}
/**
 * Factory function for creating IndividualFixedWindowStrategy instances
 * @param storage - Redis storage implementation
 * @param options - Individual fixed window configuration options
 * @returns New IndividualFixedWindowStrategy instance
 */
declare const createIndividualFixedWindowStrategy: any;
//#endregion
//#region src/strategy/sliding-window/index.d.ts
/**
 * Sliding Window Rate Limiting Strategy
 * Implements a more precise rate limiting algorithm than fixed window
 * by tracking requests across window boundaries using Redis sorted sets
 */
declare class SlidingWindowStrategy$1 extends SlidingWindowStrategy {
  private scriptSha;
  /**
   * Checks if a request is allowed under the sliding window rate limit
   * @param identifier - Unique identifier for the rate limit window
   * @returns Promise containing rate limit result with:
   *          - allowed: boolean indicating if request is permitted
   *          - remaining: number of remaining requests in window
   *          - reset: timestamp when window resets
   *          - windowStart: start timestamp of current window
   *          - windowEnd: end timestamp of current window
   */
  check(identifier: string): Promise<InferStrategyResult<SlidingWindowLimited>>;
}
/**
 * Factory function for creating SlidingWindowStrategy instances
 * @param storage - Redis storage implementation
 * @param options - Sliding window configuration options
 * @returns New SlidingWindowStrategy instance
 */
declare const createSlidingWindowStrategy: any;
//#endregion
//#region src/strategy/token-bucket/index.d.ts
/**
 * Token Bucket Rate Limiting Strategy
 * Implements an algorithm that allows bursts of requests up to a capacity,
 * with tokens refilling at a fixed rate over time
 */
declare class TokenBucketStrategy$1 extends TokenBucketStrategy {
  private scriptSha;
  /**
   * Checks if a request is allowed under the token bucket rate limit
   * @param identifier - Unique identifier for the token bucket
   * @returns Promise containing rate limit result with:
   *          - allowed: boolean indicating if request is permitted
   *          - remaining: number of remaining tokens (floored)
   *          - tokens: precise token count (may be fractional)
   *          - refillTime: time in ms between token refills
   */
  check(identifier: string): Promise<InferStrategyResult<TokenBasedLimited>>;
}
/**
 * Factory function for creating TokenBucketStrategy instances
 * @param storage - Redis storage implementation
 * @param options - Token bucket configuration options including:
 *                  - capacity: maximum tokens in bucket
 *                  - refillRate: tokens added per refill interval
 *                  - refillTime: time in ms between refills
 * @returns New TokenBucketStrategy instance
 */
declare const createTokenBucketStrategy: any;
//#endregion
export { FixedWindowStrategy$1 as FixedWindowStrategy, IndividualFixedWindowStrategy$1 as IndividualFixedWindowStrategy, SlidingWindowStrategy$1 as SlidingWindowStrategy, TokenBucketStrategy$1 as TokenBucketStrategy, createFixedWindowStrategy, createIndividualFixedWindowStrategy, createSlidingWindowStrategy, createTokenBucketStrategy };