@stimulcross/rate-limiter 0.0.2 → 0.0.3

package/lib/limiters/fixed-window/fixed-window.options.d.ts

@@ -0,0 +1,27 @@
+import { type FixedWindowState } from './fixed-window.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Fixed Window limit options.
+ */
+export interface FixedWindowLimitOptions {
+    /**
+     * Maximum number of requests allowed within the time window.
+     */
+    limit: number;
+    /**
+     * Duration of the time window in milliseconds.
+     */
+    windowMs: number;
+}
+/**
+ * Options for the Fixed Window rate limiter.
+ */
+export interface FixedWindowOptions extends RateLimiterOptions<FixedWindowState[]> {
+    /**
+     * Options time window.
+     *
+     * Can be a single object or an array of objects for composite time windows.
+     */
+    limitOptions: FixedWindowLimitOptions | FixedWindowLimitOptions[];
+}
+//# sourceMappingURL=fixed-window.options.d.ts.map

package/lib/limiters/fixed-window/fixed-window.options.js

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

package/lib/limiters/fixed-window/fixed-window.policy.d.ts

@@ -0,0 +1,19 @@
+import { type FixedWindowState } from './fixed-window.state.js';
+import { type FixedWindowStatus } from './fixed-window.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class FixedWindowPolicy implements RateLimitPolicy<FixedWindowState, FixedWindowStatus> {
+    private readonly _limit;
+    private readonly _windowMs;
+    private readonly _maxReserved;
+    constructor(_limit: number, _windowMs: number, _maxReserved?: number);
+    get limit(): number;
+    get windowMs(): number;
+    getInitialState(): FixedWindowState;
+    getStatus(state: FixedWindowState, now: number): FixedWindowStatus;
+    evaluate(state: FixedWindowState, now: number, cost: number, shouldReserve?: boolean): RateLimitPolicyResult<FixedWindowState>;
+    revert(state: FixedWindowState, cost: number, now: number): FixedWindowState;
+    private _deny;
+    private _syncState;
+}
+//# sourceMappingURL=fixed-window.policy.d.ts.map

package/lib/limiters/fixed-window/fixed-window.policy.js

@@ -118,3 +118,4 @@ export class FixedWindowPolicy {
         return { windowStart: currentWindowStart, used, reserved };
     }
 }
+//# sourceMappingURL=fixed-window.policy.js.map

package/lib/limiters/fixed-window/fixed-window.state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fixed Window rate limiter state.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface FixedWindowState {
+    windowStart: number;
+    used: number;
+    reserved: number;
+}
+//# sourceMappingURL=fixed-window.state.d.ts.map

package/lib/limiters/fixed-window/fixed-window.state.js

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

package/lib/limiters/fixed-window/fixed-window.status.d.ts

@@ -0,0 +1,39 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Fixed Window Limiter.
+ */
+export interface FixedWindowStatus extends RateLimiterStatus {
+    /**
+     * The start of the current window.
+     */
+    readonly windowStart: number;
+    /**
+     * The end of the current window.
+     */
+    readonly windowEnd: number;
+    /**
+     * The maximum number of tokens can be used in the window.
+     */
+    readonly limit: number;
+    /**
+     * The number of tokens that have been used in the current window.
+     */
+    readonly used: number;
+    /**
+     * The number of tokens that are reserved for future windows.
+     */
+    readonly reserved: number;
+    /**
+     * The number of tokens that can be used in the current window.
+     */
+    readonly remaining: number;
+    /**
+     * The timestamp (in milliseconds) when the next token will be available for use.
+     */
+    readonly nextAvailableAt: number;
+    /**
+     * The timestamp (in milliseconds) when the limit will be reset (all tokens will be available for use again).
+     */
+    readonly resetAt: number;
+}
+//# sourceMappingURL=fixed-window.status.d.ts.map

package/lib/limiters/fixed-window/fixed-window.status.js

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

package/lib/limiters/fixed-window/index.d.ts

@@ -0,0 +1,5 @@
+export type { FixedWindowState } from './fixed-window.state.js';
+export type { FixedWindowStatus } from './fixed-window.status.js';
+export type { FixedWindowLimitOptions, FixedWindowOptions } from './fixed-window.options.js';
+export { FixedWindowLimiter } from './fixed-window.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/fixed-window/index.js

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

package/lib/limiters/generic-cell/generic-cell.limiter.d.ts

@@ -0,0 +1,30 @@
+import { GenericCellPolicy } from './generic-cell.policy.js';
+import { AbstractRateLimiter, type ExecutionContext } from '../abstract-rate-limiter.js';
+import { type GenericCellOptions } from './generic-cell.options.js';
+import { type GenericCellState } from './generic-cell.state.js';
+import { type GenericCellStatus } from './generic-cell.status.js';
+/**
+ * Generic Cell (GCRA) 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 GenericCellLimiter extends AbstractRateLimiter<GenericCellState, GenericCellStatus> {
+    private readonly _defaultLimitBehaviour;
+    private readonly _defaultMaxWaitMs;
+    protected readonly _policy: GenericCellPolicy;
+    constructor(options: GenericCellOptions);
+    protected _runInternal<T>(fn: () => T | Promise<T>, ctx: ExecutionContext): Promise<T>;
+    protected _getDebugStateString(state: GenericCellState): string;
+    private _printSuccessDebug;
+}
+//# sourceMappingURL=generic-cell.limiter.d.ts.map

package/lib/limiters/generic-cell/generic-cell.limiter.js

@@ -71,3 +71,4 @@ export class GenericCellLimiter extends AbstractRateLimiter {
         }
     }
 }
+//# sourceMappingURL=generic-cell.limiter.js.map

package/lib/limiters/generic-cell/generic-cell.options.d.ts

@@ -0,0 +1,22 @@
+import { type GenericCellState } from './generic-cell.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the Generic Cell Rate Algorithm (GCRA) limiter.
+ */
+export interface GenericCellOptions extends RateLimiterOptions<GenericCellState> {
+    /**
+     * The minimum interval between requests (in milliseconds).
+     *
+     * This defines the emission interval.
+     * For example, if you want to allow 10 requests per second, set this to 100ms (1000ms / 10).
+     */
+    intervalMs: number;
+    /**
+     * The maximum burst size.
+     *
+     * This defines how many requests can be made immediately in quick succession before rate limiting kicks in.
+     * The burst capacity allows temporary spikes in traffic.
+     */
+    burst: number;
+}
+//# sourceMappingURL=generic-cell.options.d.ts.map

package/lib/limiters/generic-cell/generic-cell.options.js

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

package/lib/limiters/generic-cell/generic-cell.policy.d.ts

@@ -0,0 +1,18 @@
+import { type GenericCellState } from './generic-cell.state.js';
+import { type GenericCellStatus } from './generic-cell.status.js';
+import { type RateLimitPolicy, type RateLimitPolicyResult } from '../../core/rate-limit-policy.js';
+/** @internal */
+export declare class GenericCellPolicy implements RateLimitPolicy<GenericCellState, GenericCellStatus> {
+    private readonly _intervalMs;
+    private readonly _burst;
+    private readonly _maxDelayMs;
+    constructor(_intervalMs: number, _burst: number, _maxDelayMs?: number);
+    get burst(): number;
+    get intervalMs(): number;
+    getInitialState(): GenericCellState;
+    getStatus(state: GenericCellState, now: number): GenericCellStatus;
+    evaluate(state: GenericCellState, now: number, cost: number, shouldReserve?: boolean): RateLimitPolicyResult<GenericCellState>;
+    revert(state: GenericCellState, cost: number): GenericCellState;
+    private _deny;
+}
+//# sourceMappingURL=generic-cell.policy.d.ts.map

package/lib/limiters/generic-cell/generic-cell.policy.js

@@ -84,3 +84,4 @@ export class GenericCellPolicy {
         };
     }
 }
+//# sourceMappingURL=generic-cell.policy.js.map

package/lib/limiters/generic-cell/generic-cell.state.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generic Cell rate limiter state.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface GenericCellState {
+    tat: number;
+}
+//# sourceMappingURL=generic-cell.state.d.ts.map

package/lib/limiters/generic-cell/generic-cell.state.js

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

package/lib/limiters/generic-cell/generic-cell.status.d.ts

@@ -0,0 +1,49 @@
+import { type RateLimiterStatus } from '../../core/rate-limiter-status.js';
+/**
+ * The status of the Generic Cell rate limiter.
+ */
+export interface GenericCellStatus extends RateLimiterStatus {
+    /**
+     * The minimum interval between tokens (in milliseconds).
+     *
+     * It represents the emission interval - the time period between
+     * successive token emissions at the steady-state rate.
+     */
+    readonly intervalMs: number;
+    /**
+     * The maximum burst size (maximum number of tokens that can be accumulated).
+     *
+     * It represents the burst capacity - the maximum number of requests
+     * that can be made instantaneously when the bucket is full.
+     */
+    readonly burst: number;
+    /**
+     * Theoretical Arrival Time (TAT) - the virtual time when the bucket will be empty.
+     *
+     * TAT represents the earliest time at which a future request could be allowed.
+     *
+     * Value is in milliseconds.
+     */
+    readonly tat: number;
+    /**
+     * The number of tokens that can be used immediately.
+     *
+     * Calculated as the time allowance available between now and TAT, divided by
+     * the emission interval.
+     */
+    readonly remaining: number;
+    /**
+     * The timestamp (in milliseconds) when the next token will be available for use.
+     *
+     * This is the earliest time when a request can be accepted if no tokens are currently available.
+     */
+    readonly nextAvailableAt: number;
+    /**
+     * The timestamp when all tokens will be available for use again.
+     *
+     * It is when the TAT returns to the current time, meaning the bucket has fully recovered to its
+     * maximum burst capacity.
+     */
+    readonly resetAt: number;
+}
+//# sourceMappingURL=generic-cell.status.d.ts.map

package/lib/limiters/generic-cell/generic-cell.status.js

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

package/lib/limiters/generic-cell/index.d.ts

@@ -0,0 +1,5 @@
+export type { GenericCellState } from './generic-cell.state.js';
+export type { GenericCellStatus } from './generic-cell.status.js';
+export type { GenericCellOptions } from './generic-cell.options.js';
+export { GenericCellLimiter } from './generic-cell.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/generic-cell/index.js

@@ -1 +1,2 @@
 export { GenericCellLimiter } from './generic-cell.limiter.js';
+//# sourceMappingURL=index.js.map

package/lib/limiters/http-response-based/http-limit-info.extractor.d.ts

@@ -0,0 +1,16 @@
+import { type HttpLimitInfo } from './http-limit.info.js';
+/**
+ * A function that extracts limit information from response headers.
+ *
+ * @param res The response object, for example, native `Response` object from the `fetch` API.
+ * @param err The error object, if any.
+ * @param now The current timestamp in milliseconds gotten from the internal clock.
+ *            If you need the current timestamp, prefer this value over `Date.now()`.
+ *
+ * @returns {@link HttpLimitInfo} or `null` if not possible to extract or no limit info.
+ *
+ * @template TResponse The type of the response object.
+ * @template TError The type of the error object.
+ */
+export type HttpLimitInfoExtractor<TResponse, TError extends Error = Error> = (res: TResponse | null, err: TError | null, now: number) => HttpLimitInfo | null;
+//# sourceMappingURL=http-limit-info.extractor.d.ts.map

package/lib/limiters/http-response-based/http-limit-info.extractor.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=http-limit-info.extractor.js.map

package/lib/limiters/http-response-based/http-limit.info.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Rate limit information extracted from the HTTP response headers.
+ */
+export interface HttpLimitInfo {
+    /**
+     * The maximum number of requests allowed within the time window.
+     *
+     * It usually corresponds to `RateLimit-Limit` or `X-RateLimit-Limit` headers.
+     */
+    limit: number;
+    /**
+     * The number of requests remaining in the current time window.
+     *
+     * It usually corresponds to `RateLimit-Remaining` or `X-RateLimit-Remaining` headers.
+     */
+    remaining: number;
+    /**
+     * The timestamp (in milliseconds) when the current time window resets.
+     *
+     * It usually corresponds to `RateLimit-Reset`, `X-RateLimit-Reset`, or `Retry-After` headers.
+     *
+     * **WARNING:** these headers can be either delta (usually in seconds) or UNIX epoche
+     * timestamp (usually in seconds) depending on the target API specs.
+     *
+     *The library expects a UNIX epoche timestamp in milliseconds. Refer to the API docs to
+     * determine the header format and properly convert it to UNIX epoche timestamp in milliseconds.
+     *
+     * For example,
+     *   - delta in seconds: `Date.now() + delta * 1000`
+     *   - UNIX timestamp in seconds: `timestamp * 1000`
+     *
+     */
+    resetAt?: number | null;
+    /**
+     * HTTP status code of the response.
+     */
+    statusCode: number;
+}
+//# sourceMappingURL=http-limit.info.d.ts.map

package/lib/limiters/http-response-based/http-limit.info.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=http-limit.info.js.map

package/lib/limiters/http-response-based/http-response-based-limiter.options.d.ts

@@ -0,0 +1,17 @@
+import { type HttpLimitInfoExtractor } from './http-limit-info.extractor.js';
+import { type HttpResponseBasedLimiterState } from './http-response-based-limiter.state.js';
+import { type RateLimiterOptions } from '../../interfaces/rate-limiter-options.js';
+/**
+ * Options for the HTTP Response Based rate limiter.
+ */
+export interface HttpResponseBasedLimiterOptions<TResponse> extends RateLimiterOptions<HttpResponseBasedLimiterState> {
+    /**
+     * Function that extracts limit information from the HTTP response.
+     */
+    limitInfoExtractor: HttpLimitInfoExtractor<TResponse>;
+    /**
+     * The fallback reset delay in milliseconds.
+     */
+    fallbackResetDelayMs?: number;
+}
+//# sourceMappingURL=http-response-based-limiter.options.d.ts.map

package/lib/limiters/http-response-based/http-response-based-limiter.options.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=http-response-based-limiter.options.js.map

package/lib/limiters/http-response-based/http-response-based-limiter.state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The state of the HTTP Response Based rate limiter.
+ *
+ * When using a distributed state store, make sure it properly serializes and deserializes the state.
+ */
+export interface HttpResponseBasedLimiterState {
+    isProbing: boolean;
+    isUnlimited: boolean;
+    lastKnownLimit: number | null;
+    lastKnownRemaining: number | null;
+    lastKnownResetAt: number | null;
+    lastSyncedAt: number | null;
+}
+//# sourceMappingURL=http-response-based-limiter.state.d.ts.map

package/lib/limiters/http-response-based/http-response-based-limiter.state.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=http-response-based-limiter.state.js.map

package/lib/limiters/http-response-based/http-response-based-limiter.status.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The status of the HTTP Response Based rate limiter.
+ *
+ * This interface represents rate limit information extracted from HTTP response headers,
+ * such as RateLimit headers (RFC 6585) or custom headers provided by APIs (X-RateLimit-*).
+ *
+ * @remarks
+ * The status is updated after each API response and reflects the server-side rate limit state.
+ * Can be useful to check how many requests remain before hitting the rate limit.
+ */
+export interface HttpResponseBasedLimiterStatus {
+    /**
+     * Indicates whether the rate limiter is currently probing for the server's limit state.
+     *
+     * This is `true` when the rate limiter is waiting for the first response from the server
+     * to extract rate limit headers.
+     */
+    isProbing: boolean;
+    /**
+     * Indicates whether the rate limiter is in unlimited mode.
+     *
+     * This is `true` if a server did not send any rate limit headers.
+     *
+     * If this is `true`, the `lastKnownLimit`, `lastKnownRemaining`, and `lastKnownResetAt` values are `null`.
+     */
+    isUnlimited: boolean;
+    /**
+     * The number of requests remaining in the current rate limit window.
+     *
+     * @remarks
+     * This value is extracted from response headers such as `X-RateLimit-Remaining`
+     * or `RateLimit-Remaining`. It decrements with each request and resets when
+     * the time window expires.
+     *
+     * When this reaches 0, later requests may be delayed or rejected until the reset time.
+     */
+    lastKnownRemaining: number | null;
+    /**
+     * The maximum number of requests allowed in the current rate limit window.
+     *
+     * @remarks
+     * This value is extracted from response headers such as `X-RateLimit-Limit`
+     * or `RateLimit-Limit`. It represents the total quota allocated by the API
+     * and typically remains constant across requests within the same window.
+     */
+    lastKnownLimit: number | null;
+    /**
+     * The timestamp (in milliseconds since Unix epoch) when the rate limit window resets.
+     *
+     * `null` if the reset time is not known or not applicable.
+     *
+     * @remarks
+     * This value is extracted from response headers such as `X-RateLimit-Reset`
+     * or `RateLimit-Reset`. The exact semantics depend on the API specification:
+     *
+     * - **Full window reset**: When the entire rate limit quota is restored
+     * - **Next request availability**: When the next single request slot becomes available
+     * - **Sliding window**: When the oldest request in the window expires
+     *
+     * Always refer to your API's documentation to understand the reset behavior.
+     */
+    lastKnownResetAt: number | null;
+    /**
+     * The timestamp (in milliseconds since Unix epoch) when the status was last synced with the server.
+     *
+     * `null` if the status has never been synced.
+     */
+    lastSyncedAt: number | null;
+}
+//# sourceMappingURL=http-response-based-limiter.status.d.ts.map

package/lib/limiters/http-response-based/http-response-based-limiter.status.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=http-response-based-limiter.status.js.map

package/lib/limiters/http-response-based/http-response-based.limiter.d.ts

@@ -0,0 +1,56 @@
+import { type HttpResponseBasedLimiterOptions } from './http-response-based-limiter.options.js';
+import { type HttpResponseBasedLimiterStatus } from './http-response-based-limiter.status.js';
+import { type RateLimiter } from '../../core/rate-limiter.js';
+import { type RateLimiterRunOptions } from '../../interfaces/rate-limiter-run-options.js';
+/**
+ *  The options for single request execution.
+ */
+export type HttpHeadersLimiterRunOptions = Omit<RateLimiterRunOptions, 'cost'>;
+/**
+ * HTTP Response Based rate limiter.
+ *
+ * Designed for outbound requests to safely respect dynamic third-party API limits.
+ *
+ * This limiter synchronizes its internal state by extracting rate limit headers directly from the HTTP responses.
+ *
+ * Key features:
+ * - **Dynamic synchronization** - updates local capacity and reset schedules based on actual server responses
+ * - **Probing** - prevents 429 floods by pausing queued requests while a single "probe" fetches the latest limits
+ * - **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`
+ */
+export declare class HttpResponseBasedLimiter<TResponse> implements RateLimiter<HttpResponseBasedLimiterStatus> {
+    private readonly _logger;
+    private readonly _clock;
+    private readonly _store;
+    private readonly _executor;
+    private readonly _pendingSyncs;
+    private readonly _getStoreKey;
+    private readonly _generateId;
+    private readonly _extractLimitInfo;
+    private readonly _defaultLimitBehavior;
+    private readonly _maxWaitMs;
+    private readonly _fallbackResetDelayMs;
+    private _isDestroyed;
+    constructor(options: HttpResponseBasedLimiterOptions<TResponse>);
+    getStatus(key?: string): Promise<HttpResponseBasedLimiterStatus>;
+    run<T = TResponse>(fn: () => T | Promise<T>, options?: HttpHeadersLimiterRunOptions): Promise<T>;
+    clear(key?: string): Promise<void>;
+    destroy(): Promise<void>;
+    private get _shouldLogDebug();
+    private _executeSingleRequest;
+    private _waitForSync;
+    private _reserveLocalToken;
+    private _setupLocalProbeLock;
+    private _resolvePendingSync;
+    private _processLimitHeaders;
+    private _rollbackProbingState;
+    private _syncStateWithServer;
+    private _setUnlimited;
+    private _ensureCanExecute;
+    private _getDebugStateString;
+}
+//# sourceMappingURL=http-response-based.limiter.d.ts.map

package/lib/limiters/http-response-based/http-response-based.limiter.js

@@ -9,6 +9,12 @@ import { RateLimiterExecutor } from '../../runtime/rate-limiter.executor.js';
 import { generateRandomString } from '../../utils/generate-random-string.js';
 import { sanitizeError } from '../../utils/sanitize-error.js';
 const TOO_MANY_REQUESTS_ERROR_CODE = 429;
+var TokenReservationAction;
+(function (TokenReservationAction) {
+    TokenReservationAction[TokenReservationAction["Probe"] = 1] = "Probe";
+    TokenReservationAction[TokenReservationAction["Follow"] = 2] = "Follow";
+    TokenReservationAction[TokenReservationAction["Wait"] = 3] = "Wait";
+})(TokenReservationAction || (TokenReservationAction = {}));
 /**
  * HTTP Response Based rate limiter.
  *
@@ -148,10 +154,10 @@ export class HttpResponseBasedLimiter {
             await this._waitForSync(ctx);
             ctx.startedAt = this._clock.now();
             const action = await this._reserveLocalToken(ctx);
-            if (action === 3 /* TokenReservationAction.Wait */) {
+            if (action === TokenReservationAction.Wait) {
                 continue;
             }
-            ctx.isProbing = action === 1 /* TokenReservationAction.Probe */;
+            ctx.isProbing = action === TokenReservationAction.Probe;
             break;
         }
         try {
@@ -207,7 +213,7 @@ export class HttpResponseBasedLimiter {
         try {
             const state = await this._store.get(ctx.key);
             if (state?.isUnlimited) {
-                return 2 /* TokenReservationAction.Follow */;
+                return TokenReservationAction.Follow;
             }
             const lastKnownRemaining = state?.lastKnownRemaining ?? null;
             const lastKnownResetAt = state?.lastKnownResetAt ?? Infinity;
@@ -226,11 +232,11 @@ export class HttpResponseBasedLimiter {
                 await this._store.set(ctx.key, probeState, this._fallbackResetDelayMs);
                 this._shouldLogDebug &&
                     this._logger.debug(`[PROBE] [id: ${ctx.id}, key: ${ctx.key}] - Probing API for limits - ${this._getDebugStateString(probeState)}`);
-                return 1 /* TokenReservationAction.Probe */;
+                return TokenReservationAction.Probe;
             }
             if (state.isProbing) {
                 if (hasLocalProbe) {
-                    return 3 /* TokenReservationAction.Wait */;
+                    return TokenReservationAction.Wait;
                 }
                 throw new RateLimitError(RateLimitErrorCode.LimitExceeded, lastKnownResetAt);
             }
@@ -249,7 +255,7 @@ export class HttpResponseBasedLimiter {
             await this._store.set(ctx.key, newState, ttl);
             this._shouldLogDebug &&
                 this._logger.debug(`[RSRV] [id: ${ctx.id}, key: ${ctx.key}] - Local state - ${this._getDebugStateString(newState)}`);
-            return 2 /* TokenReservationAction.Follow */;
+            return TokenReservationAction.Follow;
         }
         finally {
             await this._store.releaseLock?.(ctx.key);
@@ -377,3 +383,4 @@ export class HttpResponseBasedLimiter {
         return `probe: ${state.isProbing}, unl: ${state.isUnlimited}, lim: ${state.lastKnownLimit}, rem: ${state.lastKnownRemaining}, rst: ${state.lastKnownResetAt}, sync: ${state.lastSyncedAt}`;
     }
 }
+//# sourceMappingURL=http-response-based.limiter.js.map

package/lib/limiters/http-response-based/index.d.ts

@@ -0,0 +1,7 @@
+export type { HttpResponseBasedLimiterState } from './http-response-based-limiter.state.js';
+export type { HttpResponseBasedLimiterStatus } from './http-response-based-limiter.status.js';
+export type { HttpResponseBasedLimiterOptions } from './http-response-based-limiter.options.js';
+export type { HttpLimitInfo } from './http-limit.info.js';
+export type { HttpLimitInfoExtractor } from './http-limit-info.extractor.js';
+export { type HttpHeadersLimiterRunOptions, HttpResponseBasedLimiter } from './http-response-based.limiter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/limiters/http-response-based/index.js

@@ -1 +1,2 @@
 export { HttpResponseBasedLimiter } from './http-response-based.limiter.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+export type { LeakyBucketState } from './leaky-bucket.state.js';
+export type { LeakyBucketStatus } from './leaky-bucket.status.js';
+export type { LeakyBucketOptions } from './leaky-bucket.options.js';
+export { LeakyBucketLimiter } from './leaky-bucket.limiter.js';
+//# sourceMappingURL=index.d.ts.map

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

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