layercache 1.3.0 → 1.3.2

package/packages/nestjs/dist/index.d.cts

@@ -1,627 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { DynamicModule, Type } from '@nestjs/common';
-
-declare const CACHE_STACK: unique symbol;
-
-interface LayerTtlMap {
-    [layerName: string]: number | undefined;
-}
-interface CacheWriteOptions {
-    tags?: string[];
-    ttl?: number | LayerTtlMap;
-    ttlPolicy?: CacheTtlPolicy;
-    negativeCache?: boolean;
-    negativeTtl?: number | LayerTtlMap;
-    staleWhileRevalidate?: number | LayerTtlMap;
-    staleIfError?: number | LayerTtlMap;
-    ttlJitter?: number | LayerTtlMap;
-    slidingTtl?: boolean;
-    refreshAhead?: number | LayerTtlMap;
-    adaptiveTtl?: boolean | CacheAdaptiveTtlOptions;
-    circuitBreaker?: CacheCircuitBreakerOptions;
-    fetcherRateLimit?: CacheRateLimitOptions;
-    /**
-     * Optional predicate called with the fetcher's return value before caching.
-     * Return `false` to skip storing the value in the cache (but still return it
-     * to the caller). Useful for not caching failed API responses or empty results.
-     *
-     * @example
-     * cache.get('key', fetchData, { shouldCache: (v) => v.status === 200 })
-     */
-    shouldCache?: (value: unknown) => boolean;
-}
-interface CacheGetOptions extends CacheWriteOptions {
-}
-interface CacheMGetEntry<T> {
-    key: string;
-    fetch?: () => Promise<T>;
-    options?: CacheGetOptions;
-}
-interface CacheMSetEntry<T> {
-    key: string;
-    value: T;
-    options?: CacheWriteOptions;
-}
-/** Interface that all cache backend implementations must satisfy. */
-interface CacheLayer {
-    readonly name: string;
-    readonly defaultTtl?: number;
-    readonly isLocal?: boolean;
-    get<T>(key: string): Promise<T | null>;
-    getEntry?<T = unknown>(key: string): Promise<T | null>;
-    /**
-     * Bulk read fast-path. Implementations should return raw stored entries using
-     * the same semantics as `getEntry()` so CacheStack can resolve envelopes,
-     * stale windows, and negative-cache markers consistently.
-     */
-    getMany?<T>(keys: string[]): Promise<Array<T | null>>;
-    setMany?(entries: CacheLayerSetManyEntry[]): Promise<void>;
-    set(key: string, value: unknown, ttl?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-    deleteMany?(keys: string[]): Promise<void>;
-    keys?(): Promise<string[]>;
-    forEachKey?(visitor: (key: string) => void | Promise<void>): Promise<void>;
-    ping?(): Promise<boolean>;
-    dispose?(): Promise<void>;
-    /**
-     * Returns true if the key exists and has not expired.
-     * Implementations may omit this; CacheStack will fall back to `get()`.
-     */
-    has?(key: string): Promise<boolean>;
-    /**
-     * Returns the remaining TTL in seconds for the key, or null if the key
-     * does not exist, has no TTL, or has already expired.
-     * Implementations may omit this.
-     */
-    ttl?(key: string): Promise<number | null>;
-    /**
-     * Returns the number of entries currently held by this layer.
-     * Implementations may omit this.
-     */
-    size?(): Promise<number>;
-}
-/** Per-layer latency statistics (rolling window of sampled read durations). */
-interface CacheLayerLatency {
-    /** Average read latency in milliseconds. */
-    avgMs: number;
-    /** Maximum observed read latency in milliseconds. */
-    maxMs: number;
-    /** Number of samples used to compute the statistics. */
-    count: number;
-}
-/** Snapshot of cumulative cache counters. */
-interface CacheMetricsSnapshot {
-    hits: number;
-    misses: number;
-    fetches: number;
-    sets: number;
-    deletes: number;
-    backfills: number;
-    invalidations: number;
-    staleHits: number;
-    refreshes: number;
-    refreshErrors: number;
-    writeFailures: number;
-    singleFlightWaits: number;
-    negativeCacheHits: number;
-    circuitBreakerTrips: number;
-    degradedOperations: number;
-    hitsByLayer: Record<string, number>;
-    missesByLayer: Record<string, number>;
-    /** Per-layer read latency statistics (sampled from successful reads). */
-    latencyByLayer: Record<string, CacheLayerLatency>;
-    /** Timestamp (ms since epoch) when metrics were last reset. */
-    resetAt: number;
-}
-/** Computed hit-rate statistics derived from CacheMetricsSnapshot. */
-interface CacheHitRateSnapshot {
-    /** Overall hit rate across all layers (0–1). */
-    overall: number;
-    /** Per-layer hit rates (0–1 each). */
-    byLayer: Record<string, number>;
-}
-interface CacheLogger {
-    debug?(message: string, context?: Record<string, unknown>): void;
-    info?(message: string, context?: Record<string, unknown>): void;
-    warn?(message: string, context?: Record<string, unknown>): void;
-    error?(message: string, context?: Record<string, unknown>): void;
-}
-interface CacheTagIndex {
-    touch(key: string): Promise<void>;
-    track(key: string, tags: string[]): Promise<void>;
-    remove(key: string): Promise<void>;
-    keysForTag(tag: string): Promise<string[]>;
-    forEachKeyForTag?(tag: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
-    keysForPrefix?(prefix: string): Promise<string[]>;
-    forEachKeyForPrefix?(prefix: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
-    /** Returns the tags associated with a specific key, or an empty array. */
-    tagsForKey?(key: string): Promise<string[]>;
-    matchPattern(pattern: string): Promise<string[]>;
-    forEachKeyMatchingPattern?(pattern: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
-    clear(): Promise<void>;
-}
-interface CacheLayerSetManyEntry {
-    key: string;
-    value: unknown;
-    ttl?: number;
-}
-interface InvalidationMessage {
-    scope: 'key' | 'keys' | 'clear';
-    sourceId: string;
-    keys?: string[];
-    operation?: 'write' | 'delete' | 'invalidate' | 'clear';
-}
-interface InvalidationBus {
-    subscribe(handler: (message: InvalidationMessage) => Promise<void> | void): Promise<() => Promise<void> | void>;
-    publish(message: InvalidationMessage): Promise<void>;
-}
-interface CacheSingleFlightExecutionOptions {
-    leaseMs: number;
-    waitTimeoutMs: number;
-    pollIntervalMs: number;
-    renewIntervalMs?: number;
-}
-interface CacheSingleFlightCoordinator {
-    execute<T>(key: string, options: CacheSingleFlightExecutionOptions, worker: () => Promise<T>, waiter: () => Promise<T>): Promise<T>;
-}
-interface CacheStackOptions {
-    logger?: CacheLogger | boolean;
-    metrics?: boolean;
-    stampedePrevention?: boolean;
-    invalidationBus?: InvalidationBus;
-    tagIndex?: CacheTagIndex;
-    generation?: number;
-    generationCleanup?: boolean | CacheGenerationCleanupOptions;
-    broadcastL1Invalidation?: boolean;
-    /**
-     * @deprecated Use `broadcastL1Invalidation` instead.
-     */
-    publishSetInvalidation?: boolean;
-    negativeCaching?: boolean;
-    negativeTtl?: number | LayerTtlMap;
-    staleWhileRevalidate?: number | LayerTtlMap;
-    staleIfError?: number | LayerTtlMap;
-    ttlJitter?: number | LayerTtlMap;
-    refreshAhead?: number | LayerTtlMap;
-    adaptiveTtl?: boolean | CacheAdaptiveTtlOptions;
-    circuitBreaker?: CacheCircuitBreakerOptions;
-    gracefulDegradation?: boolean | CacheDegradationOptions;
-    writePolicy?: 'strict' | 'best-effort';
-    writeStrategy?: 'write-through' | 'write-behind';
-    writeBehind?: CacheWriteBehindOptions;
-    fetcherRateLimit?: CacheRateLimitOptions;
-    backgroundRefreshTimeoutMs?: number;
-    singleFlightCoordinator?: CacheSingleFlightCoordinator;
-    singleFlightLeaseMs?: number;
-    singleFlightTimeoutMs?: number;
-    singleFlightPollMs?: number;
-    singleFlightRenewIntervalMs?: number;
-    snapshotBaseDir?: string | false;
-    snapshotMaxBytes?: number | false;
-    snapshotMaxEntries?: number | false;
-    invalidationMaxKeys?: number | false;
-    /**
-     * Maximum number of entries in `accessProfiles` and `circuitBreakers` maps
-     * before the oldest entries are pruned. Prevents unbounded memory growth.
-     * Defaults to 100 000.
-     */
-    maxProfileEntries?: number;
-}
-interface CacheAdaptiveTtlOptions {
-    hotAfter?: number;
-    step?: number | LayerTtlMap;
-    maxTtl?: number | LayerTtlMap;
-}
-interface CacheGenerationCleanupOptions {
-    batchSize?: number;
-}
-type CacheTtlPolicy = 'until-midnight' | 'next-hour' | {
-    alignTo: number;
-} | ((context: CacheTtlPolicyContext) => number | undefined);
-interface CacheTtlPolicyContext {
-    key: string;
-    value: unknown;
-}
-interface CacheCircuitBreakerOptions {
-    failureThreshold?: number;
-    cooldownMs?: number;
-}
-interface CacheDegradationOptions {
-    retryAfterMs?: number;
-}
-interface CacheRateLimitOptions {
-    maxConcurrent?: number;
-    intervalMs?: number;
-    maxPerInterval?: number;
-    scope?: 'global' | 'key' | 'fetcher';
-    bucketKey?: string;
-}
-interface CacheWriteBehindOptions {
-    flushIntervalMs?: number;
-    batchSize?: number;
-    maxQueueSize?: number;
-}
-interface CacheWarmEntry<T = unknown> {
-    key: string;
-    fetcher: () => Promise<T>;
-    options?: CacheGetOptions;
-    priority?: number;
-}
-/** Options controlling the cache warm-up process. */
-interface CacheWarmOptions {
-    concurrency?: number;
-    continueOnError?: boolean;
-    /** Called after each entry is processed (success or failure). */
-    onProgress?: (progress: CacheWarmProgress) => void;
-}
-/** Progress information delivered to `CacheWarmOptions.onProgress`. */
-interface CacheWarmProgress {
-    completed: number;
-    total: number;
-    key: string;
-    success: boolean;
-}
-interface CacheWrapOptions<TArgs extends unknown[] = unknown[]> extends CacheGetOptions {
-    keyResolver?: (...args: TArgs) => string;
-}
-interface CacheSnapshotEntry {
-    key: string;
-    value: unknown;
-    ttl?: number;
-}
-interface CacheStatsSnapshot {
-    metrics: CacheMetricsSnapshot;
-    layers: Array<{
-        name: string;
-        isLocal: boolean;
-        degradedUntil: number | null;
-    }>;
-    backgroundRefreshes: number;
-}
-interface CacheHealthCheckResult {
-    layer: string;
-    healthy: boolean;
-    latencyMs: number;
-    error?: string;
-}
-/** Detailed inspection result for a single cache key. */
-interface CacheInspectResult {
-    key: string;
-    /** Layers in which the key is currently stored (not expired). */
-    foundInLayers: string[];
-    /** Remaining fresh TTL in seconds, or null if no expiry or not an envelope. */
-    freshTtlSeconds: number | null;
-    /** Remaining stale-while-revalidate window in seconds, or null. */
-    staleTtlSeconds: number | null;
-    /** Remaining stale-if-error window in seconds, or null. */
-    errorTtlSeconds: number | null;
-    /** Whether the key is currently serving stale-while-revalidate. */
-    isStale: boolean;
-    /** Tags associated with this key (from the TagIndex). */
-    tags: string[];
-}
-/** All events emitted by CacheStack and their payload shapes. */
-interface CacheStackEvents {
-    /** Fired on every cache hit. */
-    hit: {
-        key: string;
-        layer: string;
-        state: 'fresh' | 'stale-while-revalidate' | 'stale-if-error';
-    };
-    /** Fired on every cache miss before the fetcher runs. */
-    miss: {
-        key: string;
-        mode: string;
-    };
-    /** Fired after a value is stored in the cache. */
-    set: {
-        key: string;
-        kind: string;
-        tags?: string[];
-    };
-    /** Fired after one or more keys are deleted. */
-    delete: {
-        keys: string[];
-    };
-    /** Fired when a value is backfilled into a faster layer. */
-    backfill: {
-        key: string;
-        layer: string;
-    };
-    /** Fired when a stale value is returned to the caller. */
-    'stale-serve': {
-        key: string;
-        state: string;
-        layer: string;
-    };
-    /** Fired when a duplicate request is deduplicated in stampede prevention. */
-    'stampede-dedupe': {
-        key: string;
-    };
-    /** Fired after a key is successfully warmed. */
-    warm: {
-        key: string;
-    };
-    /** Fired immediately before a high-level cache operation begins. */
-    'operation-start': {
-        id: number;
-        name: string;
-        attributes?: Record<string, unknown>;
-    };
-    /** Fired after a high-level cache operation finishes. */
-    'operation-end': {
-        id: number;
-        name: string;
-        attributes?: Record<string, unknown>;
-        success: boolean;
-        result?: 'null';
-        error?: unknown;
-    };
-    /** Fired when an error occurs (layer failure, circuit breaker, etc.). */
-    error: {
-        operation: string;
-        [key: string]: unknown;
-    };
-}
-
-declare class CacheNamespace {
-    private readonly cache;
-    private readonly prefix;
-    private static readonly metricsMutexes;
-    private metrics;
-    constructor(cache: CacheStack, prefix: string);
-    get<T>(key: string, fetcher?: () => Promise<T>, options?: CacheGetOptions): Promise<T | null>;
-    getOrSet<T>(key: string, fetcher: () => Promise<T>, options?: CacheGetOptions): Promise<T | null>;
-    /**
-     * Like `get()`, but throws `CacheMissError` instead of returning `null`.
-     */
-    getOrThrow<T>(key: string, fetcher?: () => Promise<T>, options?: CacheGetOptions): Promise<T>;
-    has(key: string): Promise<boolean>;
-    ttl(key: string): Promise<number | null>;
-    set<T>(key: string, value: T, options?: CacheWriteOptions): Promise<void>;
-    delete(key: string): Promise<void>;
-    mdelete(keys: string[]): Promise<void>;
-    clear(): Promise<void>;
-    mget<T>(entries: CacheMGetEntry<T>[]): Promise<Array<T | null>>;
-    mset<T>(entries: CacheMSetEntry<T>[]): Promise<void>;
-    invalidateByTag(tag: string): Promise<void>;
-    invalidateByTags(tags: string[], mode?: 'any' | 'all'): Promise<void>;
-    invalidateByPattern(pattern: string): Promise<void>;
-    invalidateByPrefix(prefix: string): Promise<void>;
-    /**
-     * Returns detailed metadata about a single cache key within this namespace.
-     */
-    inspect(key: string): Promise<CacheInspectResult | null>;
-    wrap<TArgs extends unknown[], TResult>(keyPrefix: string, fetcher: (...args: TArgs) => Promise<TResult>, options?: CacheWrapOptions<TArgs>): (...args: TArgs) => Promise<TResult | null>;
-    warm(entries: CacheWarmEntry[], options?: CacheWarmOptions): Promise<void>;
-    getMetrics(): CacheMetricsSnapshot;
-    getHitRate(): CacheHitRateSnapshot;
-    /**
-     * Creates a nested namespace. Keys are prefixed with `parentPrefix:childPrefix:`.
-     *
-     * ```ts
-     * const tenant = cache.namespace('tenant:abc')
-     * const posts = tenant.namespace('posts')
-     * // keys become: "tenant:abc:posts:mykey"
-     * ```
-     */
-    namespace(childPrefix: string): CacheNamespace;
-    qualify(key: string): string;
-    private qualifyTag;
-    private qualifyGetOptions;
-    private qualifyWrapOptions;
-    private qualifyWriteOptions;
-    private trackMetrics;
-    private getMetricsMutex;
-}
-
-/** Typed overloads for EventEmitter so callers get autocomplete on event names. */
-interface CacheStack {
-    on<K extends keyof CacheStackEvents>(event: K, listener: (data: CacheStackEvents[K]) => void): this;
-    once<K extends keyof CacheStackEvents>(event: K, listener: (data: CacheStackEvents[K]) => void): this;
-    off<K extends keyof CacheStackEvents>(event: K, listener: (data: CacheStackEvents[K]) => void): this;
-    removeAllListeners<K extends keyof CacheStackEvents>(event?: K): this;
-    listeners<K extends keyof CacheStackEvents>(event: K): Array<(data: CacheStackEvents[K]) => void>;
-    listenerCount<K extends keyof CacheStackEvents>(event: K): number;
-    emit<K extends keyof CacheStackEvents>(event: K, data: CacheStackEvents[K]): boolean;
-}
-declare class CacheStack extends EventEmitter {
-    private readonly layers;
-    private readonly options;
-    private readonly stampedeGuard;
-    private readonly metricsCollector;
-    private readonly instanceId;
-    private readonly startup;
-    private unsubscribeInvalidation?;
-    private readonly logger;
-    private readonly tagIndex;
-    private readonly keyDiscovery;
-    private readonly fetchRateLimiter;
-    private readonly snapshotSerializer;
-    private readonly invalidation;
-    private readonly layerWriter;
-    private readonly snapshots;
-    private readonly backgroundRefreshes;
-    private readonly backgroundRefreshAbort;
-    private readonly layerDegradedUntil;
-    private readonly maintenance;
-    private readonly ttlResolver;
-    private readonly circuitBreakerManager;
-    private nextOperationId;
-    private currentGeneration?;
-    private isDisconnecting;
-    private disconnectPromise?;
-    constructor(layers: CacheLayer[], options?: CacheStackOptions);
-    /**
-     * Read-through cache get.
-     * Returns the cached value if present and fresh, or invokes `fetcher` on a miss
-     * and stores the result across all layers. Returns `null` if the key is not found
-     * and no `fetcher` is provided.
-     */
-    get<T>(key: string, fetcher?: () => Promise<T>, options?: CacheGetOptions): Promise<T | null>;
-    private getPrepared;
-    /**
-     * Alias for `get(key, fetcher, options)` — explicit get-or-set pattern.
-     * Fetches and caches the value if not already present.
-     */
-    getOrSet<T>(key: string, fetcher: () => Promise<T>, options?: CacheGetOptions): Promise<T | null>;
-    /**
-     * Like `get()`, but throws `CacheMissError` instead of returning `null`.
-     * Useful when the value is expected to exist or the fetcher is expected to
-     * return non-null.
-     */
-    getOrThrow<T>(key: string, fetcher?: () => Promise<T>, options?: CacheGetOptions): Promise<T>;
-    /**
-     * Returns true if the given key exists and is not expired in any layer.
-     */
-    has(key: string): Promise<boolean>;
-    /**
-     * Returns the remaining TTL in seconds for the key in the fastest layer
-     * that has it, or null if the key is not found / has no TTL.
-     */
-    ttl(key: string): Promise<number | null>;
-    /**
-     * Stores a value in all cache layers. Overwrites any existing value.
-     */
-    set<T>(key: string, value: T, options?: CacheWriteOptions): Promise<void>;
-    /**
-     * Deletes the key from all layers and publishes an invalidation message.
-     */
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-    /**
-     * Deletes multiple keys at once. More efficient than calling `delete()` in a loop.
-     */
-    mdelete(keys: string[]): Promise<void>;
-    mget<T>(entries: CacheMGetEntry<T>[]): Promise<Array<T | null>>;
-    mset<T>(entries: CacheMSetEntry<T>[]): Promise<void>;
-    warm(entries: CacheWarmEntry[], options?: CacheWarmOptions): Promise<void>;
-    /**
-     * Returns a cached version of `fetcher`. The cache key is derived from
-     * `prefix` plus the serialized arguments unless a `keyResolver` is provided.
-     */
-    wrap<TArgs extends unknown[], TResult>(prefix: string, fetcher: (...args: TArgs) => Promise<TResult>, options?: CacheWrapOptions<TArgs>): (...args: TArgs) => Promise<TResult | null>;
-    /**
-     * Creates a `CacheNamespace` that automatically prefixes all keys with
-     * `prefix:`. Useful for multi-tenant or module-level isolation.
-     */
-    namespace(prefix: string): CacheNamespace;
-    invalidateByTag(tag: string): Promise<void>;
-    invalidateByTags(tags: string[], mode?: 'any' | 'all'): Promise<void>;
-    invalidateByPattern(pattern: string): Promise<void>;
-    invalidateByPrefix(prefix: string): Promise<void>;
-    getMetrics(): CacheMetricsSnapshot;
-    getStats(): CacheStatsSnapshot;
-    resetMetrics(): void;
-    /**
-     * Returns computed hit-rate statistics (overall and per-layer).
-     */
-    getHitRate(): CacheHitRateSnapshot;
-    healthCheck(): Promise<CacheHealthCheckResult[]>;
-    /**
-     * Rotates the active generation prefix used for all future cache keys.
-     * Previous-generation keys remain in the underlying layers until they expire,
-     * unless `generationCleanup` is enabled to prune them in the background.
-     */
-    bumpGeneration(nextGeneration?: number): number;
-    /**
-     * Returns detailed metadata about a single cache key: which layers contain it,
-     * remaining fresh/stale/error TTLs, and associated tags.
-     * Returns `null` if the key does not exist in any layer.
-     */
-    inspect(key: string): Promise<CacheInspectResult | null>;
-    exportState(): Promise<CacheSnapshotEntry[]>;
-    importState(entries: CacheSnapshotEntry[]): Promise<void>;
-    persistToFile(filePath: string): Promise<void>;
-    restoreFromFile(filePath: string): Promise<void>;
-    disconnect(): Promise<void>;
-    private initialize;
-    private fetchWithGuards;
-    private waitForFreshValue;
-    private fetchAndPopulate;
-    private storeEntry;
-    private writeBatch;
-    private readFromLayers;
-    private readLayerEntry;
-    private backfill;
-    private resolveFreshTtl;
-    private resolveLayerSeconds;
-    private shouldNegativeCache;
-    private scheduleBackgroundRefresh;
-    private runBackgroundRefresh;
-    private resolveSingleFlightOptions;
-    private deleteKeys;
-    private publishInvalidation;
-    private handleInvalidationMessage;
-    private getTagsForKey;
-    private formatError;
-    private sleep;
-    private withTimeout;
-    private shouldBroadcastL1Invalidation;
-    private observeOperation;
-    private scheduleGenerationCleanup;
-    private cleanupGeneration;
-    private initializeWriteBehind;
-    private shouldWriteBehind;
-    private enqueueWriteBehind;
-    private flushWriteBehindQueue;
-    private runWriteBehindBatch;
-    private qualifyKey;
-    private qualifyPattern;
-    private stripQualifiedKey;
-    private validateConfiguration;
-    private validateWriteOptions;
-    private assertActive;
-    private awaitStartup;
-    private applyFreshReadPolicies;
-    private shouldSkipLayer;
-    private handleLayerFailure;
-    private reportRecoverableLayerFailure;
-    private isGracefulDegradationEnabled;
-    private recordCircuitFailure;
-    private isNegativeStoredValue;
-    private emitError;
-    private snapshotMaxBytes;
-    private snapshotMaxEntries;
-    private invalidationMaxKeys;
-}
-
-interface CacheableOptions<TArgs extends unknown[]> extends CacheWrapOptions<TArgs> {
-    cache: (instance: unknown) => CacheStack;
-    prefix?: string;
-}
-declare function Cacheable<TArgs extends unknown[] = unknown[]>(options: CacheableOptions<TArgs>): MethodDecorator;
-
-interface CacheStackModuleOptions {
-    layers: CacheLayer[];
-    bridgeOptions?: CacheStackOptions;
-}
-interface CacheStackModuleAsyncOptions {
-    /**
-     * Tokens to inject into the `useFactory` function.
-     */
-    inject?: Array<Type | string | symbol>;
-    /**
-     * Async factory function that returns `CacheStackModuleOptions`.
-     * Useful when the Redis client or other dependencies must be resolved
-     * from the NestJS DI container first.
-     *
-     * ```ts
-     * CacheStackModule.forRootAsync({
-     *   inject: [ConfigService],
-     *   useFactory: (config: ConfigService) => ({
-     *     layers: [new MemoryLayer(), new RedisLayer({ client: createRedis(config) })],
-     *   })
-     * })
-     * ```
-     */
-    useFactory: (...args: unknown[]) => CacheStackModuleOptions | Promise<CacheStackModuleOptions>;
-}
-declare const InjectCacheStack: () => ParameterDecorator & PropertyDecorator;
-declare class CacheStackModule {
-    static forRoot(options: CacheStackModuleOptions): DynamicModule;
-    static forRootAsync(options: CacheStackModuleAsyncOptions): DynamicModule;
-}
-
-export { CACHE_STACK, CacheStackModule, type CacheStackModuleOptions, Cacheable, InjectCacheStack };