@daiso-tech/core 0.22.2 → 0.24.0

package/dist/cache/implementations/derivables/cache/cache.d.ts

@@ -0,0 +1,764 @@
+/**
+ * @module Cache
+ */
+import type { CacheEvents, WithTtlValue } from "../../../../cache/contracts/_module-exports.js";
+import { type ICache, type ICacheAdapter } from "../../../../cache/contracts/_module-exports.js";
+import { type IGroupableCache } from "../../../../cache/contracts/_module-exports.js";
+import type { AsyncLazyable, GetOrAddValue, OneOrMore } from "../../../../utilities/_module-exports.js";
+import type { TimeSpan } from "../../../../utilities/_module-exports.js";
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
+import { LazyPromise } from "../../../../async/_module-exports.js";
+import type { IGroupableEventBus, Listener, Unsubscribe, EventClass, EventInstance } from "../../../../event-bus/contracts/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/cache/implementations/derivables"```
+ * @group Derivables
+ */
+export type CacheSettings = {
+    adapter: ICacheAdapter<any>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     * @default {null}
+     */
+    defaultTtl?: TimeSpan | null;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     * @default {null}
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * <i>Cache</i> class can be derived from any <i>{@link ICacheAdapter}</i>.
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/cache/implementations/derivables"```
+ * @group Derivables
+ */
+export declare class Cache<TType = unknown> implements IGroupableCache<TType> {
+    private static defaultRetryPolicy;
+    private readonly groupdEventBus;
+    private readonly eventBus;
+    private readonly adapter;
+    private readonly defaultTtl;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly timeout;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     * ```
+     */
+    constructor(settings: CacheSettings);
+    private createLayPromise;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.addListener(KeyAddedCacheEvent, listener);
+     * ```
+     */
+    addListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.addListenerMany([KeyAddedCacheEvent], listener);
+     * ```
+     */
+    addListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.removeListener(KeyAddedCacheEvent, listener);
+     * ```
+     */
+    removeListener<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.removeListenerMany(KeyAddedCacheEvent, listener);
+     * ```
+     */
+    removeListenerMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * await cache.listenOnce(KeyAddedCacheEvent, listener);
+     * ```
+     */
+    listenOnce<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, listener);
+     * await unsubscribe();
+     * ```
+     */
+    subscribe<TEventClass extends EventClass<CacheEvents>>(eventName: TEventClass, listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    /**
+     * Refer to <i>{@link CacheEvents}</i>, to se all events dispatched by <i>Cache</i> class.
+     * Refer to <i>{@link IEventListener}</i> ford details on how the method works.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import type { Listener } from "@daiso-tech/core/event-bus/contracts";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     * import { KeyAddedCacheEvent, type CacheEvents } from "@daiso-tech/core/cache/contracts";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const listener: Listener<CacheEvents> = event => {
+     *   console.log(event);
+     * };
+     * const unsubscribe = await cache.subscribeMany([KeyAddedCacheEvent], listener);
+     * await unsubscribe();
+     * ```
+     */
+    subscribeMany<TEventClass extends EventClass<CacheEvents>>(eventNames: TEventClass[], listener: Listener<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache, ICache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * // Will print "@global"
+     * console.log(cache.getGroup());
+     *
+     * const groupedCache: ICache = cache.withGroup("company-1");
+     *
+     * // Will print "@global/company-1"
+     * console.log(groupedCache.getGroup());
+     * ```
+     */
+    withGroup(group: OneOrMore<string>): ICache<TType>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * // Will print "@global"
+     * console.log(cache.getGroup());
+     * ```
+     */
+    getGroup(): string;
+    get(key: string): LazyPromise<TType | null>;
+    add(key: string, value: TType, 
+    /**
+     * @default null
+     */
+    ttl?: TimeSpan | null): LazyPromise<boolean>;
+    update(key: string, value: TType): LazyPromise<boolean>;
+    put(key: string, value: TType, 
+    /**
+     * @default null
+     */
+    ttl?: TimeSpan | null): LazyPromise<boolean>;
+    remove(key: string): LazyPromise<boolean>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+    clear(): LazyPromise<void>;
+    exists(key: string): LazyPromise<boolean>;
+    existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    missing(key: string): LazyPromise<boolean>;
+    missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOr("a", -1);
+     * // -1
+     * console.log(result);
+     * ```
+     *
+     * You can pass function as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOr("a", () => -1);
+     * // -1
+     * console.log(result);
+     * ```
+     *
+     * You can pass async function as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOr("a", async () => -1);
+     * // -1
+     * console.log(result);
+     * ```
+     *
+     * You can pass <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOr("a", new LazyPromise(async () => -1));
+     * // -1
+     * console.log(result);
+     * ```
+     */
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrMany({ a: -1 });
+     * // { a: -1 }
+     * console.log(result);
+     * ```
+     *
+     * You can pass function as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrMany({ a: () => -1 });
+     * // { a: -1 }
+     * console.log(result);
+     * ```
+     *
+     * You can pass async function as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrMany({ a: async () => -1 });
+     * // { a: -1 }
+     * console.log(result);
+     * ```
+     *
+     * You can pass <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrMany({ a: new LazyPromise(async () => - 1) });
+     * // { a: -1 }
+     * console.log(result);
+     * ```
+     */
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * await cache.add("a", 1);
+     *
+     * const result1 = await cache.getOrFail("a");
+     * // Will print 1
+     * console.log(result1);
+     *
+     * await cache.remove("a");
+     *
+     * // Will throw an error
+     * await cache.getOrFail("a");
+     * ```
+     */
+    getOrFail(key: string): LazyPromise<TType>;
+    addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result1 = await cache.getAndRemove("a");
+     * // Will print null
+     * console.log(result1);
+     *
+     * await cache.add("a", 2)
+     *
+     * const result2 = await cache.getAndRemove("a");
+     * // Will print 2
+     * console.log(result2);
+     *
+     * const result3 = await cache.get("a");
+     * // Will print null
+     * console.log(result3);
+     * ```
+     */
+    getAndRemove(key: string): LazyPromise<TType | null>;
+    /**
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrAdd("a", -1);
+     * // -1
+     * console.log(result);
+     * ```
+     *
+     * You can pass function as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrAdd("a", () => -1);
+     * // -1
+     * console.log(result);
+     * ```
+     *
+     * You can pass async function as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrAdd("a", async () => -1);
+     * // -1
+     * console.log(result);
+     * ```
+     *
+     * You can pass <i>{@link LazyPromise}</i> as default value.
+     * @example
+     * ```ts
+     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import type { IGroupableEventBus } from "@daiso-tech/core/event-bus/contracts";
+     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
+     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
+     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
+     *
+     * const eventBus: IGroupableEventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cache: IGroupableCache = new Cache({
+     *   adapter: new MemoryCacheAdapter({
+     *     rootGroup: "@global"
+     *   }),
+     *   eventBus,
+     * });
+     *
+     * const result = await cache.getOrAdd("a", new LazyPromise(async () => -1));
+     * // -1
+     * console.log(result);
+     * ```
+     */
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, 
+    /**
+     * @default {null}
+     */
+    ttl?: TimeSpan): LazyPromise<TType>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
+}