@darco2903/expiry-cache 2.0.2 → 3.0.0

package/dist/base/ExpiryCacheBase.d.ts

@@ -0,0 +1,112 @@
+import { TypedEmitterProtected } from "@darco2903/typed-emitter";
+import { Time, Millisecond } from "@darco2903/secondthought";
+import type { RefreshFunction } from "../types/RefreshFunction.js";
+import type { CacheReturnType } from "../types/ReturnType.js";
+import { ReturnOptions } from "../ReturnOptions.js";
+import type { CacheEvents } from "../types/events.js";
+export declare abstract class ExpiryCacheBase<T, F extends RefreshFunction<T, E>, M extends CacheEvents<T, E>, E = never> extends TypedEmitterProtected<M> {
+    /** The cached data. */
+    protected data: T;
+    /** The function to refresh the cached data. */
+    protected refreshFn: F;
+    private _expirationTimeout;
+    /** The time in milliseconds after which the cache expires. 0 means never expires. */
+    protected _expirationTime: Millisecond;
+    /** The expiration timestamp in milliseconds. 0 means never expires, -1 means already expired or no data. */
+    protected _expiresAt: Millisecond;
+    /**
+     * Gets the expiration time in milliseconds. This is the duration after which the cache expires, not the absolute expiration timestamp.
+     */
+    get expirationTime(): number;
+    /**
+     * Gets the expiration time as a Millisecond object. This is the duration after which the cache expires, not the absolute expiration timestamp.
+     */
+    get expirationTimeAsTime(): Millisecond;
+    /**
+     * Gets the expiration timestamp in milliseconds.
+     */
+    get expiresAt(): number;
+    /**
+     * Gets the expiration timestamp as a Millisecond object.
+     */
+    get expiresAtAsTime(): Millisecond;
+    /**
+     * Checks if the cache is set to expire.
+     */
+    get doesExpire(): boolean;
+    /**
+     * Checks if the cache is expired.
+     */
+    get isExpired(): boolean;
+    /**
+     * Gets the time to live (TTL) in milliseconds. Returns null if the cache does not expire.
+     */
+    get timeToLive(): number | null;
+    /**
+     * Gets the time to live (TTL) as a Millisecond object. Returns null if the cache does not expire.
+     */
+    get timeToLiveAsTime(): Millisecond | null;
+    /**
+     * Creates an instance of ExpiryCache.
+     * @param data  The initial data to be cached.
+     * @param refreshFn The function to refresh the cached data.
+     * @param expirationTime The time in milliseconds after which the cache expires. Defaults to 60_000 (1 minute). If set to 0, the cache will never expire.
+     */
+    constructor(data: T, refreshFn: F, expirationTime?: number | Time);
+    /**
+     * Expires the cache immediately.
+     */
+    expire(): void;
+    /**
+     * Sets the cache to never expire.
+     */
+    neverExpire(): void;
+    private setExpirationTimeout;
+    /**
+     * Calculates the expiration timestamp based on the current time plus the given milliseconds. If ms is 0, it returns 0 to indicate never expires.
+     * @param ms The time in milliseconds after which the cache should expire. If set to 0, the cache will never expire.
+     */
+    protected expIn(ms: Millisecond): Millisecond;
+    /**
+     * Sets the expiration timestamp based on the current time plus the given milliseconds.
+     * @param ms The time in milliseconds after which the cache should expire. If set to 0, the cache will never expire.
+     */
+    setExpiresIn(ms: number | Time): void;
+    /**
+     * Sets the expiration timestamp to a specific time.
+     * @param expiresAt The expiration timestamp in milliseconds or as a Time object. If set to 0, the cache will never expire.
+     */
+    setExpiresAt(expiresAt: number | Time): void;
+    protected _setExpiresAt(expiresAt: Millisecond): void;
+    /**
+     * Sets the cached data and resets the expiration timestamp based on the expiration time.
+     * @param data The new data to be cached.
+     */
+    protected setData(data: T | ReturnOptions<T>): void;
+    /**
+     * Sets the cached data and sets a new expiration timestamp.
+     * @param expiresAt The new expiration timestamp in milliseconds. If set to 0, the cache will never expire.
+     */
+    protected setDataExpiresAt(data: T, expiresAt: Millisecond): void;
+    /**
+     * Sets the cached data and sets a new expiration time.
+     * @param expirationTime The new expiration time in milliseconds. If set to 0, the cache will never expire.
+     */
+    protected setDataExpiresIn(data: T, expirationTime: Millisecond): void;
+    /**
+     * Gets the cached data without checking expiration.
+     */
+    getRawData(): T;
+    /**
+     * Gets the cached data if not expired, otherwise returns null.
+     */
+    getData(): T | null;
+    /**
+     * @param args The arguments to pass to the refresh function.
+     */
+    abstract refresh(...args: Parameters<F>): CacheReturnType<T, E>;
+    /**
+     * @param args The arguments to pass to the refresh function in case the cache is expired.
+     */
+    abstract getDataOrRefresh(...args: Parameters<F>): CacheReturnType<T, E>;
+}

package/dist/base/ExpiryCacheBase.js

@@ -0,0 +1,177 @@
+import { TypedEmitterProtected } from "@darco2903/typed-emitter";
+import { Time, Millisecond, Minute } from "@darco2903/secondthought";
+import { ReturnOptions, ReturnOptionsExpiresAtClass, ReturnOptionsExpiresInClass } from "../ReturnOptions.js";
+import { argToMs } from "../utils.js";
+export class ExpiryCacheBase extends TypedEmitterProtected {
+    /**
+     * Gets the expiration time in milliseconds. This is the duration after which the cache expires, not the absolute expiration timestamp.
+     */
+    get expirationTime() {
+        return this._expirationTime.time;
+    }
+    /**
+     * Gets the expiration time as a Millisecond object. This is the duration after which the cache expires, not the absolute expiration timestamp.
+     */
+    get expirationTimeAsTime() {
+        return this._expirationTime;
+    }
+    /**
+     * Gets the expiration timestamp in milliseconds.
+     */
+    get expiresAt() {
+        return this._expiresAt.time;
+    }
+    /**
+     * Gets the expiration timestamp as a Millisecond object.
+     */
+    get expiresAtAsTime() {
+        return this._expiresAt;
+    }
+    /**
+     * Checks if the cache is set to expire.
+     */
+    get doesExpire() {
+        return this._expiresAt.time !== 0;
+    }
+    /**
+     * Checks if the cache is expired.
+     */
+    get isExpired() {
+        return this.doesExpire && Millisecond.now().greaterThanOrEqual(this._expiresAt);
+    }
+    /**
+     * Gets the time to live (TTL) in milliseconds. Returns null if the cache does not expire.
+     */
+    get timeToLive() {
+        if (this.doesExpire) {
+            return Math.max(0, this._expiresAt.clone().sub(Millisecond.now()).time);
+        }
+        return null;
+    }
+    /**
+     * Gets the time to live (TTL) as a Millisecond object. Returns null if the cache does not expire.
+     */
+    get timeToLiveAsTime() {
+        if (this.doesExpire) {
+            return Time.max(new Millisecond(0), this._expiresAt.clone().sub(Millisecond.now())).toMillisecond();
+        }
+        return null;
+    }
+    /**
+     * Creates an instance of ExpiryCache.
+     * @param data  The initial data to be cached.
+     * @param refreshFn The function to refresh the cached data.
+     * @param expirationTime The time in milliseconds after which the cache expires. Defaults to 60_000 (1 minute). If set to 0, the cache will never expire.
+     */
+    constructor(data, refreshFn, expirationTime = new Minute(1)) {
+        super();
+        const expTime = argToMs(expirationTime);
+        this.data = data;
+        this._expiresAt = expTime.time === 0 ? expTime : Millisecond.now().add(expTime);
+        this._expirationTime = expTime;
+        this.refreshFn = refreshFn;
+        this._expirationTimeout = null;
+        this.setExpirationTimeout();
+    }
+    /**
+     * Expires the cache immediately.
+     */
+    expire() {
+        this._expiresAt = new Millisecond(-1);
+        this._emit("expired");
+    }
+    /**
+     * Sets the cache to never expire.
+     */
+    neverExpire() {
+        this._expiresAt = new Millisecond(0);
+    }
+    setExpirationTimeout() {
+        if (this._expirationTimeout) {
+            clearTimeout(this._expirationTimeout);
+        }
+        if (this.timeToLive !== null) {
+            this._expirationTimeout = setTimeout(() => {
+                this._expirationTimeout = null;
+                this._emit("expired");
+            }, this.timeToLive);
+            this._expirationTimeout.unref();
+        }
+    }
+    /**
+     * Calculates the expiration timestamp based on the current time plus the given milliseconds. If ms is 0, it returns 0 to indicate never expires.
+     * @param ms The time in milliseconds after which the cache should expire. If set to 0, the cache will never expire.
+     */
+    expIn(ms) {
+        return ms.time === 0 ? ms : Millisecond.now().add(ms);
+    }
+    /**
+     * Sets the expiration timestamp based on the current time plus the given milliseconds.
+     * @param ms The time in milliseconds after which the cache should expire. If set to 0, the cache will never expire.
+     */
+    setExpiresIn(ms) {
+        const t = argToMs(ms);
+        this._expirationTime = t;
+        this._setExpiresAt(this.expIn(t));
+    }
+    /**
+     * Sets the expiration timestamp to a specific time.
+     * @param expiresAt The expiration timestamp in milliseconds or as a Time object. If set to 0, the cache will never expire.
+     */
+    setExpiresAt(expiresAt) {
+        const t = argToMs(expiresAt);
+        this._setExpiresAt(t);
+    }
+    _setExpiresAt(expiresAt) {
+        this._expiresAt = expiresAt;
+        this.setExpirationTimeout();
+    }
+    /**
+     * Sets the cached data and resets the expiration timestamp based on the expiration time.
+     * @param data The new data to be cached.
+     */
+    setData(data) {
+        if (data instanceof ReturnOptions) {
+            if (data instanceof ReturnOptionsExpiresInClass) {
+                this.setDataExpiresIn(data.data, data.expiresIn);
+            }
+            else if (data instanceof ReturnOptionsExpiresAtClass) {
+                this.setDataExpiresAt(data.data, data.expiresAt);
+            }
+        }
+        else {
+            this.setDataExpiresIn(data, this._expirationTime);
+        }
+    }
+    /**
+     * Sets the cached data and sets a new expiration timestamp.
+     * @param expiresAt The new expiration timestamp in milliseconds. If set to 0, the cache will never expire.
+     */
+    setDataExpiresAt(data, expiresAt) {
+        this.data = data;
+        this._setExpiresAt(expiresAt);
+    }
+    /**
+     * Sets the cached data and sets a new expiration time.
+     * @param expirationTime The new expiration time in milliseconds. If set to 0, the cache will never expire.
+     */
+    setDataExpiresIn(data, expirationTime) {
+        this.data = data;
+        this.setExpiresIn(expirationTime);
+    }
+    /**
+     * Gets the cached data without checking expiration.
+     */
+    getRawData() {
+        return this.data;
+    }
+    /**
+     * Gets the cached data if not expired, otherwise returns null.
+     */
+    getData() {
+        if (this.isExpired) {
+            return null;
+        }
+        return this.data;
+    }
+}

package/dist/base/ExpiryCacheSyncBase.d.ts

@@ -0,0 +1,5 @@
+import { ExpiryCacheBase } from "./ExpiryCacheBase.js";
+import type { RefreshFunctionSync } from "../types/RefreshFunction.js";
+import type { CacheEvents } from "../types/events.js";
+export declare abstract class ExpiryCacheSyncBase<T, F extends RefreshFunctionSync<T, E>, M extends CacheEvents<T, E>, E = never> extends ExpiryCacheBase<T, F, M, E> {
+}

package/dist/base/ExpiryCacheSyncBase.js

@@ -0,0 +1,3 @@
+import { ExpiryCacheBase } from "./ExpiryCacheBase.js";
+export class ExpiryCacheSyncBase extends ExpiryCacheBase {
+}

package/dist/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ExpiryCacheAsyncBase.js";
+export * from "./ExpiryCacheSyncBase.js";

package/dist/base/index.js

@@ -0,0 +1,2 @@
+export * from "./ExpiryCacheAsyncBase.js";
+export * from "./ExpiryCacheSyncBase.js";

package/dist/index.d.ts

@@ -1,2 +1,6 @@
 export * from "./ExpiryCache.js";
 export * from "./ExpiryCacheAsync.js";
+export * from "./ExpiryCacheSafe.js";
+export * from "./ExpiryCacheSafeAsync.js";
+export type * from "./types/index.js";
+export { ReturnOptions } from "./ReturnOptions.js";

package/dist/index.js

@@ -1,2 +1,5 @@
 export * from "./ExpiryCache.js";
 export * from "./ExpiryCacheAsync.js";
+export * from "./ExpiryCacheSafe.js";
+export * from "./ExpiryCacheSafeAsync.js";
+export { ReturnOptions } from "./ReturnOptions.js";

package/dist/interface/ExpiryCacheAsync.d.ts

@@ -0,0 +1,6 @@
+import type { ReturnTypeAsync } from "../types/ReturnType.js";
+import type { RefreshFunctionAsync } from "../types/RefreshFunction.js";
+export declare abstract class IExpiryCacheAsync<T, F extends RefreshFunctionAsync<T, E>, E = any> {
+    abstract refresh(...args: Parameters<F>): ReturnTypeAsync<T, E>;
+    abstract getDataOrRefresh(...args: Parameters<F>): ReturnTypeAsync<T, E>;
+}

package/dist/interface/ExpiryCacheAsync.js

@@ -0,0 +1,2 @@
+export class IExpiryCacheAsync {
+}

package/dist/interface/ExpiryCacheSafe.d.ts

@@ -0,0 +1,6 @@
+import type { ReturnTypeSafe } from "../types/ReturnType.js";
+import type { RefreshFunctionSafe } from "../types/RefreshFunction.js";
+export declare abstract class IExpiryCacheSafe<T, F extends RefreshFunctionSafe<T, E>, E> {
+    abstract refresh(...args: Parameters<F>): ReturnTypeSafe<T, E>;
+    abstract getDataOrRefresh(...args: Parameters<F>): ReturnTypeSafe<T, E>;
+}

package/dist/interface/ExpiryCacheSafe.js

@@ -0,0 +1,2 @@
+export class IExpiryCacheSafe {
+}

package/dist/interface/ExpiryCacheSync.d.ts

@@ -0,0 +1,6 @@
+import type { ReturnTypeSync } from "../types/ReturnType.js";
+import type { RefreshFunctionSync } from "../types/RefreshFunction.js";
+export declare abstract class IExpiryCacheSync<T, F extends RefreshFunctionSync<T, E>, E = any> {
+    abstract refresh(...args: Parameters<F>): ReturnTypeSync<T, E>;
+    abstract getDataOrRefresh(...args: Parameters<F>): ReturnTypeSync<T, E>;
+}

package/dist/interface/ExpiryCacheSync.js

@@ -0,0 +1,2 @@
+export class IExpiryCacheSync {
+}

package/dist/interface/ExpiryCacheUnsafe.d.ts

@@ -0,0 +1,6 @@
+import type { ReturnTypeUnsafe } from "../types/ReturnType.js";
+import type { RefreshFunctionUnsafe } from "../types/RefreshFunction.js";
+export declare abstract class IExpiryCacheUnsafe<T, F extends RefreshFunctionUnsafe<T>> {
+    abstract refresh(...args: Parameters<F>): ReturnTypeUnsafe<T>;
+    abstract getDataOrRefresh(...args: Parameters<F>): ReturnTypeUnsafe<T>;
+}

package/dist/interface/ExpiryCacheUnsafe.js

@@ -0,0 +1,2 @@
+export class IExpiryCacheUnsafe {
+}

package/dist/interface/index.d.ts

@@ -0,0 +1,4 @@
+export type * from "./ExpiryCacheAsync.js";
+export type * from "./ExpiryCacheSafe.js";
+export type * from "./ExpiryCacheSync.js";
+export type * from "./ExpiryCacheUnsafe.js";

package/dist/types/RefreshFunction.d.ts

@@ -0,0 +1,11 @@
+import type { ReturnTypeSafeAsync, ReturnTypeSafeSync, ReturnTypeUnsafeAsync, ReturnTypeUnsafeSync } from "./ReturnType.js";
+import type { ReturnOptions } from "../ReturnOptions.js";
+export type RefreshFunctionUnsafeSync<T> = (...args: any[]) => ReturnTypeUnsafeSync<T | ReturnOptions<T>>;
+export type RefreshFunctionUnsafeAsync<T> = (...args: any[]) => ReturnTypeUnsafeAsync<T | ReturnOptions<T>>;
+export type RefreshFunctionSafeSync<T, E> = (...args: any[]) => ReturnTypeSafeSync<T | ReturnOptions<T>, E>;
+export type RefreshFunctionSafeAsync<T, E> = (...args: any[]) => ReturnTypeSafeAsync<T | ReturnOptions<T>, E>;
+export type RefreshFunctionUnsafe<T> = RefreshFunctionUnsafeSync<T> | RefreshFunctionUnsafeAsync<T>;
+export type RefreshFunctionSafe<T, E> = RefreshFunctionSafeSync<T, E> | RefreshFunctionSafeAsync<T, E>;
+export type RefreshFunctionSync<T, E = never> = RefreshFunctionUnsafeSync<T> | RefreshFunctionSafeSync<T, E>;
+export type RefreshFunctionAsync<T, E = never> = RefreshFunctionUnsafeAsync<T> | RefreshFunctionSafeAsync<T, E>;
+export type RefreshFunction<T, E = never> = RefreshFunctionUnsafe<T> | RefreshFunctionSafe<T, E>;

package/dist/types/RefreshFunction.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ReturnType.d.ts

@@ -0,0 +1,10 @@
+import type { Result, ResultAsync } from "neverthrow";
+export type ReturnTypeUnsafeSync<T> = T;
+export type ReturnTypeUnsafeAsync<T> = Promise<T>;
+export type ReturnTypeSafeSync<T, U> = Result<T, U>;
+export type ReturnTypeSafeAsync<T, U> = ResultAsync<T, U>;
+export type ReturnTypeUnsafe<T> = ReturnTypeUnsafeSync<T> | ReturnTypeUnsafeAsync<T>;
+export type ReturnTypeSafe<T, U> = ReturnTypeSafeSync<T, U> | ReturnTypeSafeAsync<T, U>;
+export type ReturnTypeSync<T, U> = ReturnTypeUnsafeSync<T> | ReturnTypeSafeSync<T, U>;
+export type ReturnTypeAsync<T, U> = ReturnTypeUnsafeAsync<T> | ReturnTypeSafeAsync<T, U>;
+export type CacheReturnType<T, U> = ReturnTypeUnsafe<T> | ReturnTypeSafe<T, U>;

package/dist/types/ReturnType.js

@@ -0,0 +1 @@
+export {};

package/dist/types/events.d.ts

@@ -0,0 +1,8 @@
+export interface CacheEventsUnsafe<T> {
+    expired: [];
+    refreshed: [T];
+}
+export interface CacheEventsSafe<T, E> extends CacheEventsUnsafe<T> {
+    error: [E];
+}
+export type CacheEvents<T, E = never> = CacheEventsSafe<T, E> | CacheEventsUnsafe<T>;

package/dist/types/events.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { RefreshFunctionUnsafeSync, RefreshFunctionUnsafeAsync, RefreshFunctionSafeSync, RefreshFunctionSafeAsync, } from "./RefreshFunction.js";
+export { ReturnTypeUnsafeSync, ReturnTypeUnsafeAsync, ReturnTypeSafeSync, ReturnTypeSafeAsync, } from "./ReturnType.js";

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import { type Time, Millisecond } from "@darco2903/secondthought";
+import { ReturnOptions } from "./ReturnOptions.js";
+/**
+ * Converts a number or Time object to milliseconds.
+ */
+export declare function argToMs(arg: number | Time): Millisecond;
+/**
+ * Maps the return value of the refresh function to the actual data type. If the result is an instance of ReturnOptions, it extracts the data from it. Otherwise, it returns the result directly.
+ */
+export declare function mapRefreshReturn<T>(result: T | ReturnOptions<T>): T;

package/dist/utils.js

@@ -0,0 +1,17 @@
+import { Millisecond } from "@darco2903/secondthought";
+import { ReturnOptions } from "./ReturnOptions.js";
+/**
+ * Converts a number or Time object to milliseconds.
+ */
+export function argToMs(arg) {
+    return typeof arg === "number" ? new Millisecond(arg) : arg.toMillisecond();
+}
+/**
+ * Maps the return value of the refresh function to the actual data type. If the result is an instance of ReturnOptions, it extracts the data from it. Otherwise, it returns the result directly.
+ */
+export function mapRefreshReturn(result) {
+    if (result instanceof ReturnOptions) {
+        return result.data;
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darco2903/expiry-cache",
-  "version": "2.0.2",
+  "version": "3.0.0",
   "author": "Darco2903",
   "description": "",
   "keywords": [],
@@ -14,20 +14,23 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@darco2903/typed-emitter": "^1.3.1"
+  },
   "peerDependencies": {
-    "@darco2903/secondthought": "^1.3.0"
+    "@darco2903/secondthought": "^1.3.0",
+    "neverthrow": "^8.2.0"
   },
   "devDependencies": {
     "@darco2903/web-common": "^0.7.0",
-    "@vitest/ui": "^3.2.4",
-    "rimraf": "^6.1.0",
+    "@types/node": "^25.5.0",
+    "rimraf": "^6.1.3",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "scripts": {
     "build": "tsc",
     "test": "vitest",
-    "test:ui": "vitest --ui",
     "clean": "rimraf -g dist darco2903-expiry-cache-*.tgz"
   }
 }

package/dist/ExpiryCacheBase.d.ts

@@ -1,95 +0,0 @@
-import { type Time, Millisecond } from "@darco2903/secondthought";
-import type { RefreshFunction, RefreshFunctionAsync } from "./types.js";
-export declare abstract class ExpiryCacheBase<T, U extends RefreshFunction<T> | RefreshFunctionAsync<T>> {
-    protected data: T;
-    protected callback: U;
-    readonly expirationTime: number;
-    /** The expiration timestamp in milliseconds. 0 means never expires, -1 means already expired or no data. */
-    protected _expiresAt: Millisecond;
-    /**
-     * Gets the expiration timestamp in milliseconds.
-     */
-    get expiresAt(): number;
-    /**
-     * Checks if the cache is set to expire.
-     */
-    get doesExpire(): boolean;
-    /**
-     * Checks if the cache is expired.
-     */
-    get isExpired(): boolean;
-    /**
-     * Gets the time to live (TTL) in milliseconds.
-     */
-    get timeToLive(): number | null;
-    /**
-     * Converts a number or Time object to milliseconds.
-     */
-    protected argToMs(arg: number | Time): Millisecond;
-    /**
-     * Creates an instance of ExpiryCache.
-     * @param data  The initial data to be cached.
-     * @param callback The function to refresh the cached data.
-     * @param expirationTime The time in milliseconds after which the cache expires. Defaults to 60_000 (1 minute). If set to 0, the cache will never expire.
-     */
-    constructor(data: T, callback: U, expirationTime?: number | Time);
-    /**
-     * Expires the cache immediately.
-     */
-    expire(): void;
-    /**
-     * Sets the cache to never expire.
-     */
-    neverExpire(): void;
-    protected expIn(ms: Millisecond): Millisecond;
-    /**
-     * Sets the expiration timestamp based on the current time plus the given milliseconds.
-     * @param ms The time in milliseconds after which the cache should expire. If set to 0, the cache will never expire.
-     */
-    setExpiresIn(ms: number | Time): void;
-    /**
-     * Sets the expiration timestamp to a specific time.
-     * @param timestamp The expiration timestamp in milliseconds.
-     */
-    setExpiresAt(timestamp: number | Time): void;
-    /**
-     * Sets the cached data and resets the expiration timestamp based on the expiration time.
-     */
-    protected setData(data: T): void;
-    /**
-     * Sets the cached data and sets a new expiration timestamp.
-     * @param expiresAt The new expiration timestamp in milliseconds.
-     */
-    protected setDataExpiresAt(data: T, expiresAt: Millisecond): void;
-    /**
-     * Sets the cached data and sets a new expiration time.
-     * @param expirationTime The new expiration time in milliseconds.
-     */
-    protected setDataExpiresIn(data: T, expirationTime: Millisecond): void;
-    /**
-     * Gets the raw cached data without checking expiration.
-     */
-    getRawData(): T;
-    /**
-     * Gets the cached data if not expired, otherwise returns null.
-     */
-    getData(): T | null;
-    /**
-     * Refreshes the cached data using the callback function.
-     */
-    abstract refresh(...args: Parameters<U>): void | Promise<void>;
-    /**
-     * Gets the cached data or refreshes it if expired.
-     */
-    abstract getDataOrRefresh(...args: Parameters<U>): T | Promise<T>;
-    /**
-     * Refreshes the cached data and sets a new expiration timestamp.
-     * @param expiresAt The new expiration timestamp in milliseconds.
-     */
-    abstract refreshExpiresAt(expiresAt: number | Time, ...args: Parameters<U>): void | Promise<void>;
-    /**
-     * Refreshes the cached data and sets a new expiration time.
-     * @param expirationTime The new expiration time in milliseconds.
-     */
-    abstract refreshExpiresIn(expirationTime: number | Time, ...args: Parameters<U>): void | Promise<void>;
-}