halt-rate 0.2.0 → 0.4.0

package/dist/limiter-DqVVE0Kl.d.mts

@@ -0,0 +1,310 @@
+/**
+ * Decision model for rate limiting results.
+ */
+interface Decision {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Maximum number of requests allowed in the window */
+    limit: number;
+    /** Number of requests remaining in the current window */
+    remaining: number;
+    /** Unix timestamp when the limit resets */
+    resetAt: number;
+    /** Seconds to wait before retrying (only set when blocked) */
+    retryAfter?: number;
+}
+/**
+ * Convert decision to standard rate limit headers.
+ */
+declare function toHeaders(decision: Decision): Record<string, string>;
+
+/**
+ * Policy model for rate limiting configuration.
+ */
+declare enum KeyStrategy {
+    IP = "ip",
+    USER = "user",
+    API_KEY = "api_key",
+    COMPOSITE = "composite",
+    CUSTOM = "custom"
+}
+declare enum Algorithm {
+    TOKEN_BUCKET = "token_bucket",
+    FIXED_WINDOW = "fixed_window",
+    SLIDING_WINDOW = "sliding_window",
+    LEAKY_BUCKET = "leaky_bucket"
+}
+interface Policy {
+    /** Human-readable policy name */
+    name: string;
+    /** Maximum number of requests allowed */
+    limit: number;
+    /** Time window in seconds */
+    window: number;
+    /** Rate limiting algorithm to use */
+    algorithm?: Algorithm;
+    /** Strategy for extracting the rate limit key */
+    keyStrategy?: KeyStrategy;
+    /** Maximum burst size (for token bucket) */
+    burst?: number;
+    /** Cost per request (default: 1) */
+    cost?: number;
+    /** Duration to block after limit exceeded (seconds) */
+    blockDuration?: number;
+    /** Custom function to extract key from request */
+    keyExtractor?: (request: any) => string | null;
+    /** List of paths or IPs to exempt from rate limiting */
+    exemptions?: string[];
+    /** Optional plan/tier label for observability tagging (e.g. "pro"). */
+    plan?: string;
+}
+/**
+ * Validate and normalize policy configuration.
+ */
+declare function normalizePolicy(policy: Policy): Required<Policy>;
+
+/**
+ * In-memory storage backend for rate limiting.
+ */
+interface Store {
+    get(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    increment(key: string, delta?: number, ttl?: number): number;
+    delete(key: string): void;
+}
+declare class InMemoryStore implements Store {
+    private data;
+    get(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    increment(key: string, delta?: number, ttl?: number): number;
+    delete(key: string): void;
+    private cleanupExpired;
+    /**
+     * Clean up all expired keys.
+     */
+    cleanupAllExpired(): number;
+}
+
+/**
+ * Atomic-evaluation protocol.
+ *
+ * Simple stores (e.g. InMemoryStore) expose get/set and let the limiter run the
+ * algorithm in-process. Distributed stores that can compute the decision
+ * atomically (e.g. RedisStore via Lua) instead expose `evaluate()`: the limiter
+ * hands them the resolved policy params + storage key and gets back a finished
+ * Decision. The limiter prefers `evaluate()` when present (see core/limiter.ts).
+ */
+
+/** Everything an atomic store needs to compute a decision for one request. */
+interface EvaluateInput {
+    /** Full storage key, already namespaced (e.g. `halt:public_api:1.2.3.4`). */
+    key: string;
+    /** Algorithm to apply. */
+    algorithm: Algorithm;
+    /** Requests permitted per window. */
+    limit: number;
+    /** Window length in seconds. */
+    window: number;
+    /** Bucket capacity (token/leaky bucket). */
+    burst: number;
+    /** Cost this request consumes. */
+    cost: number;
+    /** Seconds to keep the key alive in the backing store. */
+    ttl: number;
+}
+/** A store that computes the rate-limit decision atomically on its own. */
+interface AtomicStore {
+    evaluate(input: EvaluateInput): Promise<Decision>;
+}
+/** True if the store implements the atomic-evaluation protocol. */
+declare function isAtomicStore(store: unknown): store is AtomicStore;
+/**
+ * Minimal structural type for a Redis client (satisfied by ioredis and
+ * node-redis v4+). Declared here so Halt has no hard dependency on any concrete
+ * Redis package — the user injects their own client.
+ */
+interface RedisClientLike {
+    eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;
+    evalsha?(sha: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;
+    script?(subcommand: 'LOAD', script: string): Promise<unknown>;
+}
+
+/**
+ * Quota management for SaaS platforms.
+ */
+
+declare enum QuotaPeriod {
+    HOURLY = "hourly",
+    DAILY = "daily",
+    MONTHLY = "monthly",
+    YEARLY = "yearly"
+}
+interface Quota {
+    name: string;
+    limit: number;
+    period: QuotaPeriod;
+    currentUsage?: number;
+    resetAt?: number;
+}
+declare class QuotaManager {
+    private store;
+    private telemetry?;
+    constructor(store: any, telemetry?: TelemetryHooks | undefined);
+    private getQuotaKey;
+    private calculateResetTime;
+    getQuota(identifier: string, quota: Quota): Promise<Quota>;
+    checkQuota(identifier: string, quota: Quota, cost?: number): Promise<{
+        allowed: boolean;
+        quota: Quota;
+    }>;
+    consumeQuota(identifier: string, quota: Quota, cost?: number): Promise<Quota>;
+    resetQuota(identifier: string, quota: Quota): Promise<void>;
+    remaining(quota: Quota): number;
+    isExceeded(quota: Quota): boolean;
+}
+declare const QUOTA_FREE_MONTHLY: Quota;
+declare const QUOTA_PRO_MONTHLY: Quota;
+declare const QUOTA_ENTERPRISE_MONTHLY: Quota;
+declare const QUOTA_FREE_DAILY: Quota;
+declare const QUOTA_PRO_DAILY: Quota;
+
+/**
+ * Penalty system for abuse detection and progressive rate limiting.
+ */
+
+interface PenaltyConfig {
+    threshold: number;
+    duration: number;
+    multiplier: number;
+    decayRate: number;
+}
+interface Penalty {
+    abuseScore: number;
+    penaltyUntil: number | null;
+    violations: number;
+    lastViolation: number | null;
+}
+declare class PenaltyManager {
+    private store;
+    private telemetry?;
+    private config;
+    constructor(store: any, config?: Partial<PenaltyConfig>, telemetry?: TelemetryHooks | undefined);
+    private getPenaltyKey;
+    getPenalty(identifier: string): Promise<Penalty>;
+    recordViolation(identifier: string, severity?: number): Promise<Penalty>;
+    applyPenalty(identifier: string, duration?: number): Promise<Penalty>;
+    clearPenalty(identifier: string): Promise<void>;
+    getRateLimitMultiplier(penalty: Penalty): number;
+    isActive(penalty: Penalty): boolean;
+    timeRemaining(penalty: Penalty): number;
+    private savePenalty;
+}
+declare const PENALTY_LENIENT: PenaltyConfig;
+declare const PENALTY_MODERATE: PenaltyConfig;
+declare const PENALTY_STRICT: PenaltyConfig;
+
+/**
+ * Telemetry hooks for observability and monitoring.
+ */
+
+interface TelemetryHooks {
+    onCheck?(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed?(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onBlocked?(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck?(identifier: string, quota: Quota, allowed: boolean): void;
+    onQuotaExceeded?(identifier: string, quota: Quota): void;
+    onPenaltyApplied?(identifier: string, penalty: Penalty): void;
+    onViolation?(identifier: string, penalty: Penalty, severity: number): void;
+}
+declare class LoggingTelemetry implements TelemetryHooks {
+    private logger;
+    constructor(logger?: Console);
+    onCheck(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed(key: string, decision: Decision, _metadata?: Record<string, any>): void;
+    onBlocked(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck(identifier: string, quota: Quota, allowed: boolean): void;
+    onQuotaExceeded(identifier: string, quota: Quota): void;
+    onPenaltyApplied(identifier: string, penalty: Penalty): void;
+    onViolation(identifier: string, penalty: Penalty, severity: number): void;
+}
+declare class MetricsTelemetry implements TelemetryHooks {
+    private metricsClient;
+    constructor(metricsClient: any);
+    onCheck(_key: string, _decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed(_key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onBlocked(_key: string, _decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck(_identifier: string, quota: Quota, _allowed: boolean): void;
+    onQuotaExceeded(_identifier: string, quota: Quota): void;
+    onPenaltyApplied(_identifier: string, penalty: Penalty): void;
+    onViolation(_identifier: string, _penalty: Penalty, severity: number): void;
+    private getTags;
+}
+declare class CompositeTelemetry implements TelemetryHooks {
+    private hooks;
+    constructor(hooks: TelemetryHooks[]);
+    onCheck(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onBlocked(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck(identifier: string, quota: Quota, allowed: boolean): void;
+    onQuotaExceeded(identifier: string, quota: Quota): void;
+    onPenaltyApplied(identifier: string, penalty: Penalty): void;
+    onViolation(identifier: string, penalty: Penalty, severity: number): void;
+}
+
+/**
+ * Main rate limiter implementation.
+ */
+
+interface RateLimiterOptions {
+    /**
+     * Storage backend. Either a simple KV store (InMemoryStore — the limiter runs
+     * the algorithm in-process) or an atomic store (RedisStore — the store
+     * computes the decision atomically via Lua).
+     */
+    store: Store | AtomicStore;
+    /** Either a static policy or a resolver returning a policy per-request */
+    policy: Policy | ((request: any) => Policy | Promise<Policy>);
+    trustedProxies?: string[];
+    exemptPrivateIps?: boolean;
+    /** Optional OpenTelemetry-like tracer (object with startSpan) */
+    otelTracer?: any;
+    /** Optional metrics recorder: (name, tags?, value?) => void */
+    metricsRecorder?: (name: string, tags?: Record<string, string>, value?: number) => void;
+    /**
+     * Optional high-level observability hooks (StatsCollector, OpenTelemetryMetrics,
+     * LoggingTelemetry, or a CompositeTelemetry of several). Called on every
+     * rate-limited check with rich metadata (policy, algorithm, endpoint, cost, plan).
+     */
+    telemetry?: TelemetryHooks;
+}
+declare class RateLimiter {
+    private store;
+    private policyOrResolver;
+    private trustedProxies;
+    private exemptPrivateIps;
+    private algorithmCache;
+    private otelTracer?;
+    private metricsRecorder?;
+    private telemetry?;
+    constructor(options: RateLimiterOptions);
+    /** Fan a finished decision out to the telemetry hooks with rich metadata. */
+    private emitTelemetry;
+    /**
+     * Check if request is allowed under rate limit.
+     */
+    /**
+     * Check if request is allowed under rate limit.
+     * This method is async because policy resolution may be async (e.g. DB lookup).
+     */
+    check(request: any, cost?: number): Promise<Decision>;
+    /**
+     * Extract rate limit key from request based on policy strategy.
+     */
+    private extractKey;
+    /**
+     * Check if request is exempt from rate limiting.
+     */
+    private isExempt;
+}
+
+export { type AtomicStore as A, CompositeTelemetry as C, type Decision as D, type EvaluateInput as E, InMemoryStore as I, KeyStrategy as K, LoggingTelemetry as L, MetricsTelemetry as M, type Policy as P, type Quota as Q, type RedisClientLike as R, type Store as S, type TelemetryHooks as T, type Penalty as a, Algorithm as b, PENALTY_LENIENT as c, PENALTY_MODERATE as d, PENALTY_STRICT as e, type PenaltyConfig as f, PenaltyManager as g, QUOTA_ENTERPRISE_MONTHLY as h, QUOTA_FREE_DAILY as i, QUOTA_FREE_MONTHLY as j, QUOTA_PRO_DAILY as k, QUOTA_PRO_MONTHLY as l, QuotaManager as m, QuotaPeriod as n, RateLimiter as o, type RateLimiterOptions as p, isAtomicStore as q, normalizePolicy as r, toHeaders as t };

package/dist/limiter-DqVVE0Kl.d.ts

@@ -0,0 +1,310 @@
+/**
+ * Decision model for rate limiting results.
+ */
+interface Decision {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Maximum number of requests allowed in the window */
+    limit: number;
+    /** Number of requests remaining in the current window */
+    remaining: number;
+    /** Unix timestamp when the limit resets */
+    resetAt: number;
+    /** Seconds to wait before retrying (only set when blocked) */
+    retryAfter?: number;
+}
+/**
+ * Convert decision to standard rate limit headers.
+ */
+declare function toHeaders(decision: Decision): Record<string, string>;
+
+/**
+ * Policy model for rate limiting configuration.
+ */
+declare enum KeyStrategy {
+    IP = "ip",
+    USER = "user",
+    API_KEY = "api_key",
+    COMPOSITE = "composite",
+    CUSTOM = "custom"
+}
+declare enum Algorithm {
+    TOKEN_BUCKET = "token_bucket",
+    FIXED_WINDOW = "fixed_window",
+    SLIDING_WINDOW = "sliding_window",
+    LEAKY_BUCKET = "leaky_bucket"
+}
+interface Policy {
+    /** Human-readable policy name */
+    name: string;
+    /** Maximum number of requests allowed */
+    limit: number;
+    /** Time window in seconds */
+    window: number;
+    /** Rate limiting algorithm to use */
+    algorithm?: Algorithm;
+    /** Strategy for extracting the rate limit key */
+    keyStrategy?: KeyStrategy;
+    /** Maximum burst size (for token bucket) */
+    burst?: number;
+    /** Cost per request (default: 1) */
+    cost?: number;
+    /** Duration to block after limit exceeded (seconds) */
+    blockDuration?: number;
+    /** Custom function to extract key from request */
+    keyExtractor?: (request: any) => string | null;
+    /** List of paths or IPs to exempt from rate limiting */
+    exemptions?: string[];
+    /** Optional plan/tier label for observability tagging (e.g. "pro"). */
+    plan?: string;
+}
+/**
+ * Validate and normalize policy configuration.
+ */
+declare function normalizePolicy(policy: Policy): Required<Policy>;
+
+/**
+ * In-memory storage backend for rate limiting.
+ */
+interface Store {
+    get(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    increment(key: string, delta?: number, ttl?: number): number;
+    delete(key: string): void;
+}
+declare class InMemoryStore implements Store {
+    private data;
+    get(key: string): any;
+    set(key: string, value: any, ttl?: number): void;
+    increment(key: string, delta?: number, ttl?: number): number;
+    delete(key: string): void;
+    private cleanupExpired;
+    /**
+     * Clean up all expired keys.
+     */
+    cleanupAllExpired(): number;
+}
+
+/**
+ * Atomic-evaluation protocol.
+ *
+ * Simple stores (e.g. InMemoryStore) expose get/set and let the limiter run the
+ * algorithm in-process. Distributed stores that can compute the decision
+ * atomically (e.g. RedisStore via Lua) instead expose `evaluate()`: the limiter
+ * hands them the resolved policy params + storage key and gets back a finished
+ * Decision. The limiter prefers `evaluate()` when present (see core/limiter.ts).
+ */
+
+/** Everything an atomic store needs to compute a decision for one request. */
+interface EvaluateInput {
+    /** Full storage key, already namespaced (e.g. `halt:public_api:1.2.3.4`). */
+    key: string;
+    /** Algorithm to apply. */
+    algorithm: Algorithm;
+    /** Requests permitted per window. */
+    limit: number;
+    /** Window length in seconds. */
+    window: number;
+    /** Bucket capacity (token/leaky bucket). */
+    burst: number;
+    /** Cost this request consumes. */
+    cost: number;
+    /** Seconds to keep the key alive in the backing store. */
+    ttl: number;
+}
+/** A store that computes the rate-limit decision atomically on its own. */
+interface AtomicStore {
+    evaluate(input: EvaluateInput): Promise<Decision>;
+}
+/** True if the store implements the atomic-evaluation protocol. */
+declare function isAtomicStore(store: unknown): store is AtomicStore;
+/**
+ * Minimal structural type for a Redis client (satisfied by ioredis and
+ * node-redis v4+). Declared here so Halt has no hard dependency on any concrete
+ * Redis package — the user injects their own client.
+ */
+interface RedisClientLike {
+    eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;
+    evalsha?(sha: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;
+    script?(subcommand: 'LOAD', script: string): Promise<unknown>;
+}
+
+/**
+ * Quota management for SaaS platforms.
+ */
+
+declare enum QuotaPeriod {
+    HOURLY = "hourly",
+    DAILY = "daily",
+    MONTHLY = "monthly",
+    YEARLY = "yearly"
+}
+interface Quota {
+    name: string;
+    limit: number;
+    period: QuotaPeriod;
+    currentUsage?: number;
+    resetAt?: number;
+}
+declare class QuotaManager {
+    private store;
+    private telemetry?;
+    constructor(store: any, telemetry?: TelemetryHooks | undefined);
+    private getQuotaKey;
+    private calculateResetTime;
+    getQuota(identifier: string, quota: Quota): Promise<Quota>;
+    checkQuota(identifier: string, quota: Quota, cost?: number): Promise<{
+        allowed: boolean;
+        quota: Quota;
+    }>;
+    consumeQuota(identifier: string, quota: Quota, cost?: number): Promise<Quota>;
+    resetQuota(identifier: string, quota: Quota): Promise<void>;
+    remaining(quota: Quota): number;
+    isExceeded(quota: Quota): boolean;
+}
+declare const QUOTA_FREE_MONTHLY: Quota;
+declare const QUOTA_PRO_MONTHLY: Quota;
+declare const QUOTA_ENTERPRISE_MONTHLY: Quota;
+declare const QUOTA_FREE_DAILY: Quota;
+declare const QUOTA_PRO_DAILY: Quota;
+
+/**
+ * Penalty system for abuse detection and progressive rate limiting.
+ */
+
+interface PenaltyConfig {
+    threshold: number;
+    duration: number;
+    multiplier: number;
+    decayRate: number;
+}
+interface Penalty {
+    abuseScore: number;
+    penaltyUntil: number | null;
+    violations: number;
+    lastViolation: number | null;
+}
+declare class PenaltyManager {
+    private store;
+    private telemetry?;
+    private config;
+    constructor(store: any, config?: Partial<PenaltyConfig>, telemetry?: TelemetryHooks | undefined);
+    private getPenaltyKey;
+    getPenalty(identifier: string): Promise<Penalty>;
+    recordViolation(identifier: string, severity?: number): Promise<Penalty>;
+    applyPenalty(identifier: string, duration?: number): Promise<Penalty>;
+    clearPenalty(identifier: string): Promise<void>;
+    getRateLimitMultiplier(penalty: Penalty): number;
+    isActive(penalty: Penalty): boolean;
+    timeRemaining(penalty: Penalty): number;
+    private savePenalty;
+}
+declare const PENALTY_LENIENT: PenaltyConfig;
+declare const PENALTY_MODERATE: PenaltyConfig;
+declare const PENALTY_STRICT: PenaltyConfig;
+
+/**
+ * Telemetry hooks for observability and monitoring.
+ */
+
+interface TelemetryHooks {
+    onCheck?(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed?(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onBlocked?(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck?(identifier: string, quota: Quota, allowed: boolean): void;
+    onQuotaExceeded?(identifier: string, quota: Quota): void;
+    onPenaltyApplied?(identifier: string, penalty: Penalty): void;
+    onViolation?(identifier: string, penalty: Penalty, severity: number): void;
+}
+declare class LoggingTelemetry implements TelemetryHooks {
+    private logger;
+    constructor(logger?: Console);
+    onCheck(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed(key: string, decision: Decision, _metadata?: Record<string, any>): void;
+    onBlocked(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck(identifier: string, quota: Quota, allowed: boolean): void;
+    onQuotaExceeded(identifier: string, quota: Quota): void;
+    onPenaltyApplied(identifier: string, penalty: Penalty): void;
+    onViolation(identifier: string, penalty: Penalty, severity: number): void;
+}
+declare class MetricsTelemetry implements TelemetryHooks {
+    private metricsClient;
+    constructor(metricsClient: any);
+    onCheck(_key: string, _decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed(_key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onBlocked(_key: string, _decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck(_identifier: string, quota: Quota, _allowed: boolean): void;
+    onQuotaExceeded(_identifier: string, quota: Quota): void;
+    onPenaltyApplied(_identifier: string, penalty: Penalty): void;
+    onViolation(_identifier: string, _penalty: Penalty, severity: number): void;
+    private getTags;
+}
+declare class CompositeTelemetry implements TelemetryHooks {
+    private hooks;
+    constructor(hooks: TelemetryHooks[]);
+    onCheck(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onAllowed(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onBlocked(key: string, decision: Decision, metadata?: Record<string, any>): void;
+    onQuotaCheck(identifier: string, quota: Quota, allowed: boolean): void;
+    onQuotaExceeded(identifier: string, quota: Quota): void;
+    onPenaltyApplied(identifier: string, penalty: Penalty): void;
+    onViolation(identifier: string, penalty: Penalty, severity: number): void;
+}
+
+/**
+ * Main rate limiter implementation.
+ */
+
+interface RateLimiterOptions {
+    /**
+     * Storage backend. Either a simple KV store (InMemoryStore — the limiter runs
+     * the algorithm in-process) or an atomic store (RedisStore — the store
+     * computes the decision atomically via Lua).
+     */
+    store: Store | AtomicStore;
+    /** Either a static policy or a resolver returning a policy per-request */
+    policy: Policy | ((request: any) => Policy | Promise<Policy>);
+    trustedProxies?: string[];
+    exemptPrivateIps?: boolean;
+    /** Optional OpenTelemetry-like tracer (object with startSpan) */
+    otelTracer?: any;
+    /** Optional metrics recorder: (name, tags?, value?) => void */
+    metricsRecorder?: (name: string, tags?: Record<string, string>, value?: number) => void;
+    /**
+     * Optional high-level observability hooks (StatsCollector, OpenTelemetryMetrics,
+     * LoggingTelemetry, or a CompositeTelemetry of several). Called on every
+     * rate-limited check with rich metadata (policy, algorithm, endpoint, cost, plan).
+     */
+    telemetry?: TelemetryHooks;
+}
+declare class RateLimiter {
+    private store;
+    private policyOrResolver;
+    private trustedProxies;
+    private exemptPrivateIps;
+    private algorithmCache;
+    private otelTracer?;
+    private metricsRecorder?;
+    private telemetry?;
+    constructor(options: RateLimiterOptions);
+    /** Fan a finished decision out to the telemetry hooks with rich metadata. */
+    private emitTelemetry;
+    /**
+     * Check if request is allowed under rate limit.
+     */
+    /**
+     * Check if request is allowed under rate limit.
+     * This method is async because policy resolution may be async (e.g. DB lookup).
+     */
+    check(request: any, cost?: number): Promise<Decision>;
+    /**
+     * Extract rate limit key from request based on policy strategy.
+     */
+    private extractKey;
+    /**
+     * Check if request is exempt from rate limiting.
+     */
+    private isExempt;
+}
+
+export { type AtomicStore as A, CompositeTelemetry as C, type Decision as D, type EvaluateInput as E, InMemoryStore as I, KeyStrategy as K, LoggingTelemetry as L, MetricsTelemetry as M, type Policy as P, type Quota as Q, type RedisClientLike as R, type Store as S, type TelemetryHooks as T, type Penalty as a, Algorithm as b, PENALTY_LENIENT as c, PENALTY_MODERATE as d, PENALTY_STRICT as e, type PenaltyConfig as f, PenaltyManager as g, QUOTA_ENTERPRISE_MONTHLY as h, QUOTA_FREE_DAILY as i, QUOTA_FREE_MONTHLY as j, QUOTA_PRO_DAILY as k, QUOTA_PRO_MONTHLY as l, QuotaManager as m, QuotaPeriod as n, RateLimiter as o, type RateLimiterOptions as p, isAtomicStore as q, normalizePolicy as r, toHeaders as t };