@stimulcross/rate-limiter 0.0.2 → 0.0.3

package/lib/limiters/leaky-bucket/leaky-bucket.limiter.d.ts

@@ -0,0 +1,30 @@
+import { type LeakyBucketOptions } from './leaky-bucket.options.js';
+import { LeakyBucketPolicy } from './leaky-bucket.policy.js';
+import { type LeakyBucketState } from './leaky-bucket.state.js';
+import { type LeakyBucketStatus } from './leaky-bucket.status.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+/**
+ * Leaky Bucket rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Key features:
+ * - **Queueing & overflow** - optionally enqueues excess requests up to a maximum allowed overflow capacity
+ * - **Concurrency** - limits how many requests can be executed simultaneously
+ * - **Priority** - supports task priorities (with fairness and custom policy) to execute critical requests first
+ * - **Cancellation** - supports `AbortSignal` to safely remove pending requests from the queue
+ * - **Expiration** - automatically drops queued requests that wait longer than the allowed `maxWaitMs`
+ * - **Auto-rollback** - reverts spent quota if an enqueued task is canceled or expired
+ */
+export declare class LeakyBucketLimiter extends AbstractRateLimiter<LeakyBucketState, LeakyBucketStatus> {
+    private readonly _defaultLimitBehaviour;
+    private readonly _maxWaitMs;
+    protected readonly _policy: LeakyBucketPolicy;
+    constructor(options: LeakyBucketOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: LeakyBucketState): string;
+    private _printDebug;
+}
+//# sourceMappingURL=leaky-bucket.limiter.d.ts.map

package/lib/limiters/leaky-bucket/leaky-bucket.limiter.js

@@ -72,3 +72,4 @@ export class LeakyBucketLimiter extends AbstractRateLimiter {
         }
     }
 }
+//# sourceMappingURL=leaky-bucket.limiter.js.map

package/lib/limiters/leaky-bucket/leaky-bucket.options.d.ts

@@ -0,0 +1,22 @@
+import { type LeakyBucketState } from './leaky-bucket.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Leaky Bucket rate limiter.
+ */
+export interface LeakyBucketOptions extends RateLimiterOptions<LeakyBucketState> {
+    /**
+     * The maximum number of requests that can be queued in the bucket.
+     *
+     * In the Leaky Bucket algorithm, this represents the maximum depth of the bucket
+     * that holds incoming requests before they leak out at a constant rate.
+     */
+    capacity: number;
+    /**
+     * The rate at which requests are processed from the bucket (requests per second).
+     *
+     * This defines the constant rate at which requests "leak" out of the bucket
+     * and are allowed to proceed.
+     */
+    leakRate: number;
+}
+//# sourceMappingURL=leaky-bucket.options.d.ts.map

package/lib/limiters/leaky-bucket/leaky-bucket.options.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=leaky-bucket.options.js.map

package/lib/limiters/leaky-bucket/leaky-bucket.policy.d.ts

@@ -0,0 +1,19 @@
+import { type LeakyBucketState } from './leaky-bucket.state.js';
+import { type LeakyBucketStatus } from './leaky-bucket.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class LeakyBucketPolicy implements RateLimitPolicy<LeakyBucketState, LeakyBucketStatus> {
+    private readonly _capacity;
+    private readonly _leakRate;
+    private readonly _maxOverflow;
+    constructor(_capacity: number, _leakRate: number, _maxOverflow?: number);
+    get capacity(): number;
+    get leakRate(): number;
+    getInitialState(): LeakyBucketState;
+    getStatus(state: LeakyBucketState, now: number): LeakyBucketStatus;
+    evaluate(state: LeakyBucketState, now: number, cost: number, shouldReserve?: boolean): RateLimitPolicyResult<LeakyBucketState>;
+    revert(state: LeakyBucketState, cost: number, now: number): LeakyBucketState;
+    private _deny;
+    private _syncState;
+}
+//# sourceMappingURL=leaky-bucket.policy.d.ts.map

package/lib/limiters/leaky-bucket/leaky-bucket.policy.js

@@ -98,3 +98,4 @@ export class LeakyBucketPolicy {
         };
     }
 }
+//# sourceMappingURL=leaky-bucket.policy.js.map

package/lib/limiters/leaky-bucket/leaky-bucket.state.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Leaky Bucket rate limiter state.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface LeakyBucketState {
+    level: number;
+    lastUpdate: number;
+}
+//# sourceMappingURL=leaky-bucket.state.d.ts.map

package/lib/limiters/leaky-bucket/leaky-bucket.state.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=leaky-bucket.state.js.map

package/lib/limiters/leaky-bucket/leaky-bucket.status.d.ts

@@ -0,0 +1,31 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Leaky Bucket rate limiter.
+ */
+export interface LeakyBucketStatus extends RateLimiterStatus {
+    /**
+     * The maximum capacity of the bucket (maximum number of requests that can be queued).
+     */
+    capacity: number;
+    /**
+     * The rate at which requests leak from the bucket (requests per second).
+     */
+    leakRate: number;
+    /**
+     * The current number of requests in the bucket waiting to be processed.
+     */
+    level: number;
+    /**
+     * The number of requests that can still be added to the bucket before reaching capacity.
+     */
+    remaining: number;
+    /**
+     * Timestamp (in milliseconds) when the next request slot will become available.
+     */
+    nextAvailableAt: number;
+    /**
+     * Timestamp (in milliseconds) when all queued requests will have leaked (bucket becomes empty).
+     */
+    resetAt: number;
+}
+//# sourceMappingURL=leaky-bucket.status.d.ts.map

package/lib/limiters/leaky-bucket/leaky-bucket.status.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=leaky-bucket.status.js.map

package/lib/limiters/sliding-window-counter/index.d.ts

@@ -0,0 +1,5 @@
+export type { SlidingWindowCounterState } from './sliding-window-counter.state.js';
+export type { SlidingWindowCounterStatus } from './sliding-window-counter.status.js';
+export type { SlidingWindowCounterOptions } from './sliding-window-counter.options.js';
+export { type SlidingWindowCounterLimiterRunOptions, SlidingWindowCounterLimiter, } from './sliding-window-counter.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/sliding-window-counter/index.js

@@ -1 +1,2 @@
 export { SlidingWindowCounterLimiter, } from './sliding-window-counter.limiter.js';
+//# sourceMappingURL=index.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.limiter.d.ts

@@ -0,0 +1,28 @@
+import { type SlidingWindowCounterOptions } from './sliding-window-counter.options.js';
+import { SlidingWindowCounterPolicy } from './sliding-window-counter.policy.js';
+import { type SlidingWindowCounterState } from './sliding-window-counter.state.js';
+import { type SlidingWindowCounterStatus } from './sliding-window-counter.status.js';
+import { type RateLimiterRunOptions } from '../../interfaces/rate-limiter-run-options.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+/**
+ * The options for running a task in the Sliding Window Counter rate limiter.
+ */
+export type SlidingWindowCounterLimiterRunOptions = Omit<RateLimiterRunOptions, 'limitBehavior' | 'priority' | 'maxWaitMs'>;
+/**
+ * Sliding Window Counter rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Note: Unlike queue-based limiters, this implementation operates in strict immediate mode.
+ * It does not support request queueing, delays, priorities, or task cancellation.
+ */
+export declare class SlidingWindowCounterLimiter extends AbstractRateLimiter<SlidingWindowCounterState, SlidingWindowCounterStatus> {
+    protected readonly _policy: SlidingWindowCounterPolicy;
+    private readonly _storeTtl;
+    constructor(options: SlidingWindowCounterOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: SlidingWindowCounterState): string;
+}
+//# sourceMappingURL=sliding-window-counter.limiter.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.limiter.js

@@ -44,3 +44,4 @@ export class SlidingWindowCounterLimiter extends AbstractRateLimiter {
         return `lim: ${this._policy.limit}; c/p: ${state.currentCount}/${state.previousCount}`;
     }
 }
+//# sourceMappingURL=sliding-window-counter.limiter.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.options.d.ts

@@ -0,0 +1,16 @@
+import { type SlidingWindowCounterState } from './sliding-window-counter.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Sliding Window Counter rate limiter.
+ */
+export interface SlidingWindowCounterOptions extends Omit<RateLimiterOptions<SlidingWindowCounterState>, 'queue' | 'limitBehavior'> {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+}
+//# sourceMappingURL=sliding-window-counter.options.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.options.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sliding-window-counter.options.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.policy.d.ts

@@ -0,0 +1,18 @@
+import { type SlidingWindowCounterState } from './sliding-window-counter.state.js';
+import { type SlidingWindowCounterStatus } from './sliding-window-counter.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class SlidingWindowCounterPolicy implements RateLimitPolicy<SlidingWindowCounterState, SlidingWindowCounterStatus> {
+    private readonly _limit;
+    private readonly _windowMs;
+    constructor(_limit: number, _windowMs: number);
+    get limit(): number;
+    get windowMs(): number;
+    getInitialState(): SlidingWindowCounterState;
+    getStatus(state: SlidingWindowCounterState, now: number): SlidingWindowCounterStatus;
+    evaluate(state: SlidingWindowCounterState, now: number, cost: number): RateLimitPolicyResult<SlidingWindowCounterState>;
+    revert(state: SlidingWindowCounterState, cost: number, now: number): SlidingWindowCounterState;
+    private _syncState;
+    private _calculateAvailableAt;
+}
+//# sourceMappingURL=sliding-window-counter.policy.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.policy.js

@@ -125,3 +125,4 @@ export class SlidingWindowCounterPolicy {
         return Math.max(now, absoluteTime);
     }
 }
+//# sourceMappingURL=sliding-window-counter.policy.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sliding Window Counter rate limiter state.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface SlidingWindowCounterState {
+    windowStart: number;
+    currentCount: number;
+    previousCount: number;
+}
+//# sourceMappingURL=sliding-window-counter.state.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.state.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sliding-window-counter.state.js.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.status.d.ts

@@ -0,0 +1,45 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Sliding Window Counter rate limiter.
+ */
+export interface SlidingWindowCounterStatus extends RateLimiterStatus {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+    /**
+     * Timestamp (in milliseconds) when the current window started.
+     */
+    windowStart: number;
+    /**
+     * Number of requests made in the current window.
+     */
+    currentCount: number;
+    /**
+     * Number of requests made in the previous window.
+     */
+    previousCount: number;
+    /**
+     * Estimated request count based on the sliding window algorithm.
+     *
+     * Calculated by combining current and previous window counts proportionally.
+     */
+    estimatedCount: number;
+    /**
+     * Number of requests remaining before hitting the limit.
+     */
+    remaining: number;
+    /**
+     * Timestamp (in milliseconds) when the next request slot becomes available.
+     */
+    nextAvailableAt: number;
+    /**
+     * Timestamp (in milliseconds) when the current window resets.
+     */
+    resetAt: number;
+}
+//# sourceMappingURL=sliding-window-counter.status.d.ts.map

package/lib/limiters/sliding-window-counter/sliding-window-counter.status.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sliding-window-counter.status.js.map

package/lib/limiters/sliding-window-log/index.d.ts

@@ -0,0 +1,5 @@
+export type { SlidingWindowLogEntry, SlidingWindowLogState } from './sliding-window-log.state.js';
+export type { SlidingWindowLogStatus } from './sliding-window-log.status.js';
+export type { SlidingWindowLogOptions } from './sliding-window-log.options.js';
+export { type SlidingWindowLogLimiterRunOptions, SlidingWindowLogLimiter } from './sliding-window-log.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/sliding-window-log/index.js

@@ -1 +1,2 @@
 export { SlidingWindowLogLimiter } from './sliding-window-log.limiter.js';
+//# sourceMappingURL=index.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.limiter.d.ts

@@ -0,0 +1,27 @@
+import { type SlidingWindowLogOptions } from './sliding-window-log.options.js';
+import { SlidingWindowLogPolicy } from './sliding-window-log.policy.js';
+import { type SlidingWindowLogState } from './sliding-window-log.state.js';
+import { type SlidingWindowLogStatus } from './sliding-window-log.status.js';
+import { type RateLimiterRunOptions } from '../../interfaces/rate-limiter-run-options.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+/**
+ * The options for running a task in the Sliding Window Log rate limiter.
+ */
+export type SlidingWindowLogLimiterRunOptions = Omit<RateLimiterRunOptions, 'limitBehavior' | 'priority'>;
+/**
+ * Sliding Window Log rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Note: Unlike queue-based limiters, this implementation operates in strict immediate mode.
+ * It does not support request queueing, delays, priorities, or task cancellation.
+ */
+export declare class SlidingWindowLogLimiter extends AbstractRateLimiter<SlidingWindowLogState, SlidingWindowLogStatus> {
+    protected readonly _policy: SlidingWindowLogPolicy;
+    constructor(options: SlidingWindowLogOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: SlidingWindowLogState): string;
+}
+//# sourceMappingURL=sliding-window-log.limiter.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.limiter.js

@@ -41,3 +41,4 @@ export class SlidingWindowLogLimiter extends AbstractRateLimiter {
         return `used/lim: ${state.totalUsed}/${this._policy.limit} logs: ${state.logs.size}`;
     }
 }
+//# sourceMappingURL=sliding-window-log.limiter.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.options.d.ts

@@ -0,0 +1,16 @@
+import { type SlidingWindowLogState } from './sliding-window-log.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Sliding Window Log rate limiter.
+ */
+export interface SlidingWindowLogOptions extends Omit<RateLimiterOptions<SlidingWindowLogState>, 'queue' | 'limitBehavior'> {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+}
+//# sourceMappingURL=sliding-window-log.options.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.options.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sliding-window-log.options.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.policy.d.ts

@@ -0,0 +1,18 @@
+import { type SlidingWindowLogState } from './sliding-window-log.state.js';
+import { type SlidingWindowLogStatus } from './sliding-window-log.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class SlidingWindowLogPolicy implements RateLimitPolicy<SlidingWindowLogState, SlidingWindowLogStatus> {
+    private readonly _limit;
+    private readonly _windowMs;
+    constructor(_limit: number, _windowMs: number);
+    get limit(): number;
+    get windowMs(): number;
+    getInitialState(): SlidingWindowLogState;
+    getStatus(state: SlidingWindowLogState, now: number): SlidingWindowLogStatus;
+    evaluate(state: SlidingWindowLogState, now: number, cost: number): RateLimitPolicyResult<SlidingWindowLogState>;
+    revert(state: SlidingWindowLogState, cost: number, now: number): SlidingWindowLogState;
+    private _syncState;
+    private _calculateAvailableAt;
+}
+//# sourceMappingURL=sliding-window-log.policy.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.policy.js

@@ -121,3 +121,4 @@ export class SlidingWindowLogPolicy {
         return Math.max(now, availableAt);
     }
 }
+//# sourceMappingURL=sliding-window-log.policy.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.state.d.ts

@@ -0,0 +1,18 @@
+import { type Deque } from '@stimulcross/ds-deque';
+/**
+ * A log entry in the sliding window log rate limiter.
+ */
+export interface SlidingWindowLogEntry {
+    ts: number;
+    count: number;
+}
+/**
+ * The state of the sliding window log rate limiter.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface SlidingWindowLogState {
+    logs: Deque<SlidingWindowLogEntry>;
+    totalUsed: number;
+}
+//# sourceMappingURL=sliding-window-log.state.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.state.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sliding-window-log.state.js.map

package/lib/limiters/sliding-window-log/sliding-window-log.status.d.ts

@@ -0,0 +1,39 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Sliding Window Log rate limiter.
+ */
+export interface SlidingWindowLogStatus extends RateLimiterStatus {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * The sliding time window duration in milliseconds.
+     */
+    windowMs: number;
+    /**
+     * Total number of requests consumed within the current sliding window.
+     *
+     * This count includes all requests that fall within the window period.
+     */
+    totalUsed: number;
+    /**
+     * Number of remaining requests available before hitting the limit.
+     */
+    remaining: number;
+    /**
+     * The timestamp (in milliseconds) when the next request slot will become available.
+     *
+     * This is based on when the oldest request in the window will expire.
+     */
+    nextAvailableAt: number;
+    /**
+     * The timestamp (in milliseconds) when the current window will fully reset.
+     *
+     * Represents when the last (most recent) request in the log will expire.
+     *
+     * After this time, all requests will have aged out of the sliding window.
+     */
+    resetAt: number;
+}
+//# sourceMappingURL=sliding-window-log.status.d.ts.map

package/lib/limiters/sliding-window-log/sliding-window-log.status.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sliding-window-log.status.js.map

package/lib/limiters/token-bucket/index.d.ts

@@ -0,0 +1,5 @@
+export type { TokenBucketState } from './token-bucket.state.js';
+export type { TokenBucketStatus } from './token-bucket.status.js';
+export type { TokenBucketOptions } from './token-bucket.options.js';
+export { TokenBucketLimiter } from './token-bucket.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/token-bucket/index.js

@@ -1 +1,2 @@
 export { TokenBucketLimiter } from './token-bucket.limiter.js';
+//# sourceMappingURL=index.js.map

package/lib/limiters/token-bucket/token-bucket.limiter.d.ts

@@ -0,0 +1,30 @@
+import { type TokenBucketOptions } from './token-bucket.options.js';
+import { TokenBucketPolicy } from './token-bucket.policy.js';
+import { type TokenBucketState } from './token-bucket.state.js';
+import { type TokenBucketStatus } from './token-bucket.status.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+/**
+ * Token Bucket rate limiter.
+ *
+ * Designed primarily for client-side use to respect third-party limits or protect resources.
+ * While this can be used as a server-side limiter with custom distributed storage
+ * (e.g., Redis), it is best-effort and not recommended due to high network round-trip latency.
+ *
+ * Key features:
+ * - **Queueing & overflow** - optionally enqueues excess requests up to a maximum allowed overflow capacity
+ * - **Concurrency** - limits how many requests can be executed simultaneously
+ * - **Priority** - supports task priorities (with fairness and custom policy) to execute critical requests first
+ * - **Cancellation** - supports `AbortSignal` to safely remove pending requests from the queue
+ * - **Expiration** - automatically drops queued requests that wait longer than the allowed `maxWaitMs`
+ * - **Auto-rollback** - reverts spent quota if an enqueued task is canceled or expired
+ */
+export declare class TokenBucketLimiter extends AbstractRateLimiter<TokenBucketState, TokenBucketStatus> {
+    private readonly _defaultLimitBehaviour;
+    private readonly _maxWaitMs;
+    protected readonly _policy: TokenBucketPolicy;
+    constructor(options: TokenBucketOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: TokenBucketState): string;
+    private _printSuccessDebug;
+}
+//# sourceMappingURL=token-bucket.limiter.d.ts.map

package/lib/limiters/token-bucket/token-bucket.limiter.js

@@ -72,3 +72,4 @@ export class TokenBucketLimiter extends AbstractRateLimiter {
         }
     }
 }
+//# sourceMappingURL=token-bucket.limiter.js.map

package/lib/limiters/token-bucket/token-bucket.options.d.ts

@@ -0,0 +1,16 @@
+import { type TokenBucketState } from './token-bucket.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Token Bucket rate limiter.
+ */
+export interface TokenBucketOptions extends RateLimiterOptions<TokenBucketState> {
+    /**
+     * The maximum number of tokens that can be stored in the bucket.
+     */
+    capacity: number;
+    /**
+     * The rate, in seconds, at which tokens are refilled.
+     */
+    refillRate: number;
+}
+//# sourceMappingURL=token-bucket.options.d.ts.map

package/lib/limiters/token-bucket/token-bucket.options.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=token-bucket.options.js.map

package/lib/limiters/token-bucket/token-bucket.policy.d.ts

@@ -0,0 +1,19 @@
+import { type TokenBucketState } from './token-bucket.state.js';
+import { type TokenBucketStatus } from './token-bucket.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class TokenBucketPolicy implements RateLimitPolicy<TokenBucketState, TokenBucketStatus> {
+    private readonly _capacity;
+    private readonly _refillRate;
+    private readonly _maxDebt;
+    constructor(_capacity: number, _refillRate: number, _maxDebt?: number);
+    get capacity(): number;
+    get refillRate(): number;
+    getInitialState(): TokenBucketState;
+    getStatus(state: TokenBucketState, now: number): TokenBucketStatus;
+    evaluate(state: TokenBucketState, now: number, cost: number, shouldReserve?: boolean): RateLimitPolicyResult<TokenBucketState>;
+    revert(state: TokenBucketState, cost: number, now: number): TokenBucketState;
+    private _deny;
+    private _syncState;
+}
+//# sourceMappingURL=token-bucket.policy.d.ts.map

package/lib/limiters/token-bucket/token-bucket.policy.js

@@ -113,3 +113,4 @@ export class TokenBucketPolicy {
         return { tokens, debt, lastRefill: now };
     }
 }
+//# sourceMappingURL=token-bucket.policy.js.map

package/lib/limiters/token-bucket/token-bucket.state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Token Bucket rate limiter state.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface TokenBucketState {
+    tokens: number;
+    debt: number;
+    lastRefill: number;
+}
+//# sourceMappingURL=token-bucket.state.d.ts.map

package/lib/limiters/token-bucket/token-bucket.state.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=token-bucket.state.js.map

package/lib/limiters/token-bucket/token-bucket.status.d.ts

@@ -0,0 +1,31 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Token Bucket rate limiter.
+ */
+export interface TokenBucketStatus extends RateLimiterStatus {
+    /**
+     * The maximum number of tokens that can be stored in the bucket.
+     */
+    capacity: number;
+    /**
+     * The rate, in seconds, at which tokens are refilled.
+     */
+    refillRate: number;
+    /**
+     * The number of tokens available in the bucket.
+     */
+    tokens: number;
+    /**
+     * The number of tokens that have been reserved.
+     */
+    debt: number;
+    /**
+     * The timestamp (in milliseconds) at which next token will be available for use.
+     */
+    nextAvailableAt: number;
+    /**
+     * The timestamp (in milliseconds) at which the bucket will be reset.
+     */
+    resetAt: number;
+}
+//# sourceMappingURL=token-bucket.status.d.ts.map

package/lib/limiters/token-bucket/token-bucket.status.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=token-bucket.status.js.map

package/lib/runtime/default-clock.d.ts

@@ -0,0 +1,4 @@
+import { type Clock } from '../core/clock.js';
+/** @internal */
+export declare const defaultClock: Clock;
+//# sourceMappingURL=default-clock.d.ts.map

package/lib/runtime/default-clock.js

@@ -4,3 +4,4 @@ export const defaultClock = {
         return Date.now();
     },
 };
+//# sourceMappingURL=default-clock.js.map