@daiso-tech/core 0.15.0 → 0.17.4

package/dist/types/cache/implementations/adapters/mongodb-cache-adapter/_module.d.ts

@@ -1 +1,2 @@
-export * from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter";
+export * from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
+export * from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter";

package/dist/types/cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module Cache
+ */
+import type { IBuildable } from "../../../../utilities/_module";
+import { type OneOrMore } from "../../../../utilities/_module";
+import type { CollectionOptions, Db, ObjectId } from "mongodb";
+import type { ISerde } from "../../../../serde/contracts/_module";
+/**
+ * @internal
+ */
+export type MongodbCacheDocument = {
+    _id: ObjectId;
+    key: string;
+    group: string;
+    value: number | string;
+    expiresAt: Date | null;
+};
+/**
+ * @group Adapters
+ */
+export type MongodbCacheAdapterSettings = {
+    database: Db;
+    serde: ISerde<string>;
+    rootGroup: OneOrMore<string>;
+    collectionName?: string;
+    collectionSettings?: CollectionOptions;
+};
+/**
+ * The <i>MongodbCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class MongodbCacheAdapterSettingsBuilder<TSettings extends Partial<MongodbCacheAdapterSettings>> implements IBuildable<MongodbCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setDatabase(database: Db): MongodbCacheAdapterSettingsBuilder<TSettings & {
+        database: Db;
+    }>;
+    setSerde(serde: ISerde<string>): MongodbCacheAdapterSettingsBuilder<TSettings & {
+        serde: ISerde<string>;
+    }>;
+    setRootGroup(group: OneOrMore<string>): MongodbCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    setCollectionName(name: string): MongodbCacheAdapterSettingsBuilder<TSettings & {
+        collectionName: string;
+    }>;
+    setCollectionSettings(settings: CollectionOptions): MongodbCacheAdapterSettingsBuilder<TSettings & {
+        collectionSettings: CollectionOptions;
+    }>;
+    build(this: MongodbCacheAdapterSettingsBuilder<MongodbCacheAdapterSettings>): MongodbCacheAdapterSettings;
+}

package/dist/types/cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter.d.ts

@@ -2,56 +2,81 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan, IInitizable } from "../../../../utilities/_module";
-import type { ObjectId } from "mongodb";
-import { type Collection } from "mongodb";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { IDeinitizable } from "../../../../utilities/_module";
+import { type TimeSpan, type IInitizable, type OneOrMore } from "../../../../utilities/_module";
+import type { MongodbCacheAdapterSettings } from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
+import { MongodbCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/mongodb-cache-adapter/mongodb-cache-adapter-settings";
 /**
+ * To utilize the <i>MongodbCacheAdapter</i>, you must install the <i>"mongodb"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
-export type MongodbCacheDocument = {
-    _id: ObjectId;
-    key: string;
-    value: number | string;
-    expiresAt: Date | null;
-};
-/**
- * @group Adapters
- */
-export type MongodbCacheAdapterSettings = {
-    serializer: ISerializer<string>;
-};
-/**
- * To utilize the <i>MongodbCacheAdapter</i>, you must install the <i>"mongodb"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { MongodbCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
- * import { MongoClient } from "mongodb";
- *
- * const client = new MongoClient("YOUR_MONGODB_CONNECTION_STRING");
- * const database = client.db("database");
- * const cacheCollection = database.collection("cache");
- * const serializer = new SuperJsonSerializer();
- * const cacheAdapter = new MongodbCacheAdapter(cacheCollection, {
- *   serializer,
- * });
- *   // You only need to call it once before using the adapter.
- *   await cacheAdapter.init();
- *   await cacheAdapter.add("a", 1);
- * ```
- */
-export declare class MongodbCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable {
-    private readonly collection;
+export declare class MongodbCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    /**
+     * @example
+     * ```ts
+     * import { MongodbCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { MongoClient } from "mongodb";
+     *
+     * (async () => {
+     *   const client = await MongoClient.connect("YOUR_MONGODB_CONNECTION_STRING");
+     *   const cacheAdapter = new MongodbCacheAdapter(
+     *     MongodbCacheAdapter
+     *       .settings()
+     *       .setDatabase(client.db("database"))
+     *       .setSerde(new SuperJsonSerde())
+     *       .setRootGroup("@global")
+     *       .build()
+     *   );
+     * })();
+     * ```
+     */
+    static settings<TSettings extends Partial<MongodbCacheAdapterSettings>>(): MongodbCacheAdapterSettingsBuilder<TSettings>;
     private static isMongodbIncrementError;
-    private serializer;
-    constructor(collection: Collection<MongodbCacheDocument>, { serializer }: MongodbCacheAdapterSettings);
+    private readonly mongodbSerde;
+    private readonly group;
+    private readonly baseSerde;
+    private readonly database;
+    private readonly collection;
+    private readonly collectionName;
+    /**
+     * @example
+     * ```ts
+     * import { MongodbCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { MongoClient } from "mongodb";
+     *
+     * (async () => {
+     *   const client = await MongoClient.connect("YOUR_MONGODB_CONNECTION_STRING");
+     *   const database = client.db("database");
+     *   const serde = new SuperJsonSerde();
+     *   const cacheAdapter = new MongodbCacheAdapter({
+     *     database,
+     *     serde,
+     *     rootGroup: "@global"
+     *   });
+     *
+     *   await cacheAdapter.init();
+     *   await cacheAdapter.add("a", 1);
+     *   await cacheAdapter.deInit();
+     * })();
+     * ```
+     */
+    constructor({ collectionName, collectionSettings, database, serde, rootGroup, }: MongodbCacheAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
+    /**
+     * Creates all related indexes.
+     */
     init(): Promise<void>;
+    /**
+     * Removes the collection where the cache values are stored and all it's related indexes.
+     */
+    deInit(): Promise<void>;
+    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;
     put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     remove(key: string): Promise<boolean>;
     increment(key: string, value: number): Promise<boolean>;
-    clear(prefix: string): Promise<void>;
+    clear(): Promise<void>;
 }

package/dist/types/cache/implementations/adapters/no-op-cache-adapter/no-op-cache-adapter.d.ts

@@ -2,17 +2,20 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan } from "../../../../utilities/_module";
+import type { OneOrMore, TimeSpan } from "../../../../utilities/_module";
 /**
  * This <i>NoOpCacheAdapter</i> will do nothing and is used for easily mocking {@link ICacheAdapter} for testing.
  * @group Adapters
  */
-export declare class NoOpCacheAdapter<TType> implements ICacheAdapter<TType> {
+export declare class NoOpCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
+    getGroup(): string;
+    withGroup(_group: OneOrMore<string>): ICacheAdapter<TType>;
+    exists(_key: string): Promise<boolean>;
     get(_key: string): Promise<TType | null>;
     add(_key: string, _value: TType, _ttl: TimeSpan | null): Promise<boolean>;
     update(_key: string, _value: TType): Promise<boolean>;
     put(_key: string, _value: TType, _ttl: TimeSpan | null): Promise<boolean>;
     remove(_key: string): Promise<boolean>;
     increment(_key: string, _value: number): Promise<boolean>;
-    clear(_prefix: string): Promise<void>;
+    clear(): Promise<void>;
 }

package/dist/types/cache/implementations/adapters/redis-cache-adapter/_module.d.ts

@@ -1 +1,2 @@
+export * from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter";

package/dist/types/cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module Cache
+ */
+import type { IBuildable, OneOrMore } from "../../../../utilities/_module";
+import type { Redis } from "ioredis";
+import type { ISerde } from "../../../../serde/contracts/_module";
+/**
+ * @group Adapters
+ */
+export type RedisCacheAdapterSettings = {
+    database: Redis;
+    serde: ISerde<string>;
+    rootGroup: OneOrMore<string>;
+};
+/**
+ * The <i>RedisCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class RedisCacheAdapterSettingsBuilder<TSettings extends Partial<RedisCacheAdapterSettings>> implements IBuildable<RedisCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setDatabase(database: Redis): RedisCacheAdapterSettingsBuilder<TSettings & {
+        database: Redis;
+    }>;
+    setSerde(serde: ISerde<string>): RedisCacheAdapterSettingsBuilder<TSettings & {
+        serde: ISerde<string>;
+    }>;
+    setRootGroup(group: OneOrMore<string>): RedisCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: RedisCacheAdapterSettingsBuilder<RedisCacheAdapterSettings>): RedisCacheAdapterSettings;
+}

package/dist/types/cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter.d.ts

@@ -2,42 +2,62 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan } from "../../../../utilities/_module";
-import { type Redis, type Result } from "ioredis";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { OneOrMore } from "../../../../utilities/_module";
+import { type TimeSpan } from "../../../../utilities/_module";
+import { type Result } from "ioredis";
+import type { RedisCacheAdapterSettings } from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
+import { RedisCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/redis-cache-adapter/redis-cache-adapter-settings";
 declare module "ioredis" {
     interface RedisCommander<Context> {
-        daiso_storage_increment(key: string, number: string): Result<number, Context>;
-        daiso_storage_put(key: string, value: string): Result<string, Context>;
-        daiso_storage_getOrAdd(key: string, valueToAdd: string): Result<string, Context>;
+        daiso_cache_increment(key: string, number: string): Result<number, Context>;
     }
 }
 /**
+ * To utilize the <i>RedisCacheAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
-export type RedisCacheAdapterSettings = {
-    serializer: ISerializer<string>;
-};
-/**
- * To utilize the <i>RedisCacheAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { RedisCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
- * import Redis from "ioredis";
- *
- * const client = new Redis("YOUR_REDIS_CONNECTION_STRING");
- * const serializer = new SuperJsonSerializer();
- * const cacheAdapter = new RedisCacheAdapter(client, {
- *   serializer,
- * });
- * ```
- */
-export declare class RedisCacheAdapter<TType> implements ICacheAdapter<TType> {
-    private readonly client;
+export declare class RedisCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
+    /**
+     * @example
+     * ```ts
+     * import { RedisCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheAdapter = new RedisCacheAdapter(
+     *   RedisCacheAdapter
+     *     .settings()
+     *     .setDatabase(new Redis("YOUR_REDIS_CONNECTION_STRING"))
+     *     .setSerde(new SuperJsonSerde())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<RedisCacheAdapterSettings>>(): RedisCacheAdapterSettingsBuilder<TSettings>;
     private static isRedisTypeError;
-    private serializer;
-    constructor(client: Redis, { serializer }: RedisCacheAdapterSettings);
+    private readonly baseSerde;
+    private readonly redisSerde;
+    private readonly group;
+    private readonly database;
+    /**
+     * @example
+     * ```ts
+     * import { RedisCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const database = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const serde = new SuperJsonSerde();
+     * const cacheAdapter = new RedisCacheAdapter({
+     *   database,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     * ```
+     */
+    constructor({ database, serde, rootGroup }: RedisCacheAdapterSettings);
+    private getGroupName;
+    private withPrefix;
+    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;
@@ -45,5 +65,7 @@ export declare class RedisCacheAdapter<TType> implements ICacheAdapter<TType> {
     remove(key: string): Promise<boolean>;
     private initIncrementCommand;
     increment(key: string, value: number): Promise<boolean>;
-    clear(prefix: string): Promise<void>;
+    clear(): Promise<void>;
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
 }

package/dist/types/cache/implementations/adapters/sqlite-cache-adapter/_module.d.ts

@@ -1 +1,2 @@
+export * from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings";
 export * from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter";

package/dist/types/cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module Cache
+ */
+import type { ISerde } from "../../../../serde/contracts/_module";
+import type { TimeSpan, OneOrMore, IBuildable } from "../../../../utilities/_module";
+import { type SqliteDatabase } from "kysely";
+/**
+ * @group Adapters
+ */
+export type SqliteCacheAdapterSettings = {
+    database: SqliteDatabase;
+    tableName?: string;
+    serde: ISerde<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
+};
+/**
+ * The <i>SqliteCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class SqliteCacheAdapterSettingsBuilder<TSettings extends Partial<SqliteCacheAdapterSettings>> implements IBuildable<SqliteCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setDatabase(database: SqliteDatabase): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        database: SqliteDatabase;
+    }>;
+    setTableName(name: string): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        tableName: string;
+    }>;
+    setSerde(serde: ISerde<string>): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        serde: ISerde<string>;
+    }>;
+    setEnableTransactions(enable: boolean): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        enableTransactions: boolean;
+    }>;
+    setExpiredKeysRemovalInterval(interval: TimeSpan): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        expiredKeysRemovalInterval: TimeSpan;
+    }>;
+    setShouldRemoveExpiredKeys(shouldRemove: boolean): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        shouldRemoveExpiredKeys: boolean;
+    }>;
+    setRootGroup(group: OneOrMore<string>): SqliteCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: SqliteCacheAdapterSettingsBuilder<SqliteCacheAdapterSettings>): SqliteCacheAdapterSettings;
+}

package/dist/types/cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter.d.ts

@@ -2,51 +2,71 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
-import type { TimeSpan, IInitizable, IDeinitizable } from "../../../../utilities/_module";
-import { type Database } from "better-sqlite3";
+import type { TimeSpan, IInitizable, IDeinitizable, OneOrMore } from "../../../../utilities/_module";
+import type { SqliteCacheAdapterSettings } from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings";
+import { SqliteCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/sqlite-cache-adapter/sqlite-cache-adapter-settings";
 /**
+ * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
-export type SqliteStorageAdapterSettings = {
-    tableName?: string;
-    serializer: ISerializer<string>;
-    enableTransactions?: boolean;
-    expiredKeysRemovalInterval?: TimeSpan;
-    shouldRemoveExpiredKeys?: boolean;
-};
-/**
- * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { SqliteCacheAdapter, SuperJsonSerializer } from "@daiso-tech/core";
- * import Sqlite from "better-sqlite3";
- *
- * const client = new Sqlite("local.db");
- * const serializer = new SuperJsonSerializer();
- * const cacheAdapter = new SqliteCacheAdapter(client, {
- *   serializer,
- * });
- *   // You only need to call it once before using the adapter.
- *   await cacheAdapter.init();
- *   await cacheAdapter.add("a", 1);
- *
- *   // Will remove the cache
- *   await cacheAdapter.deInit();
- * ```
- */
-export declare class SqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+export declare class SqliteCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    /**
+     * @example
+     * ```ts
+     * import { SqliteCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Sqlite from "better-sqlite3";
+     *
+     * const cacheAdapter = new SqliteCacheAdapter(
+     *   SqliteCacheAdapter
+     *     .settings()
+     *     .setDatabase(new Sqlite("local.db"))
+     *     .setSerde(new SuperJsonSerde())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<SqliteCacheAdapterSettings>>(): SqliteCacheAdapterSettingsBuilder<TSettings>;
     private readonly cacheAdapter;
-    constructor(database: Database, settings: SqliteStorageAdapterSettings);
+    /**
+     * @example
+     * ```ts
+     * import { SqliteCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import Sqlite from "better-sqlite3";
+     *
+     * const database = new Sqlite("local.db");
+     * const serde = new SuperJsonSerde();
+     * const cacheAdapter = new SqliteCacheAdapter({
+     *   database,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     *
+     * (async () => {
+     *   await cacheAdapter.init();
+     *   await cacheAdapter.add("a", 1);
+     *   await cacheAdapter.deInit();
+     * })();
+     * ```
+     */
+    constructor(settings: SqliteCacheAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     removeExpiredKeys(): Promise<void>;
+    /**
+     * Removes the table where the cache values are stored and removes the table indexes.
+     */
     deInit(): Promise<void>;
+    /**
+     * Creates the table where the cache values are stored and it's related indexes.
+     */
     init(): Promise<void>;
+    exists(key: string): Promise<boolean>;
     get(key: string): Promise<TType | null>;
     add(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     update(key: string, value: TType): Promise<boolean>;
     put(key: string, value: TType, ttl: TimeSpan | null): Promise<boolean>;
     remove(key: string): Promise<boolean>;
     increment(key: string, value: number): Promise<boolean>;
-    clear(prefix: string): Promise<void>;
+    clear(): Promise<void>;
 }

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

@@ -1,3 +1,4 @@
-export * from "../../../cache/implementations/derivables/base-cache";
-export * from "../../../cache/implementations/derivables/cache";
+export * from "../../../cache/implementations/derivables/cache-factory-settings";
 export * from "../../../cache/implementations/derivables/cache-factory";
+export * from "../../../cache/implementations/derivables/cache-settings";
+export * from "../../../cache/implementations/derivables/cache";

package/dist/types/cache/implementations/derivables/cache-factory-settings.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @module Cache
+ */
+import type { IGroupableEventBus } from "../../../event-bus/contracts/_module";
+import type { ICacheAdapter } from "../../../cache/contracts/_module";
+import type { TimeSpan } from "../../../utilities/_module";
+import type { BackoffPolicy, RetryPolicy } from "../../../async/_module";
+/**
+ * @group Derivables
+ */
+export type CacheAdapters<TAdapters extends string> = Partial<Record<TAdapters, ICacheAdapter<any>>>;
+/**
+ * @group Derivables
+ */
+export type CacheFactorySettings<TAdapters extends string = string> = {
+    adapters: CacheAdapters<TAdapters>;
+    defaultAdapter?: NoInfer<TAdapters>;
+    /**
+     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     */
+    defaultTtl?: TimeSpan;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * The default retry attempt to use in the returned <i>LazyPromise</i>.
+     */
+    retryAttempts?: number | null;
+    /**
+     * The default backof policy to use in the returned <i>LazyPromise</i>.
+     */
+    backoffPolicy?: BackoffPolicy | null;
+    /**
+     * The default retry policy to use in the returned <i>LazyPromise</i>.
+     */
+    retryPolicy?: RetryPolicy | null;
+    /**
+     * The default timeout to use in the returned <i>LazyPromise</i>.
+     */
+    timeout?: TimeSpan | null;
+};
+/**
+ * The <i>CacheFactorySettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Derivables
+ */
+export declare class CacheFactorySettingsBuilder<TSettings extends CacheFactorySettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setEventBus(eventBus: IGroupableEventBus<any>): CacheFactorySettingsBuilder<TSettings & {
+        eventBus: IGroupableEventBus<any>;
+    }>;
+    setDefultTtl(time: TimeSpan): CacheFactorySettingsBuilder<TSettings & {
+        defaultTtl: TimeSpan;
+    }>;
+    setRetryAttempts(attempts: number | null): CacheFactorySettingsBuilder<TSettings & {
+        retryAttempts: number | null;
+    }>;
+    setBackoffPolicy(policy: BackoffPolicy | null): CacheFactorySettingsBuilder<TSettings & {
+        backoffPolicy: BackoffPolicy | null;
+    }>;
+    setRetryPolicy(policy: RetryPolicy | null): CacheFactorySettingsBuilder<TSettings & {
+        retryPolicy: RetryPolicy | null;
+    }>;
+    setTimeout(time: TimeSpan | null): CacheFactorySettingsBuilder<TSettings & {
+        timeout: TimeSpan | null;
+    }>;
+    setAdapter<TName extends string>(name: TName, adapter: ICacheAdapter<any>): CacheFactorySettingsBuilder<TSettings & {
+        adapters: {
+            readonly [x: string]: ICacheAdapter<any> | undefined;
+        };
+    }>;
+    setDefaultAdapter(adapter: string): CacheFactorySettingsBuilder<TSettings & {
+        defaultAdapter: string;
+    }>;
+    build(this: CacheFactorySettingsBuilder<CacheFactorySettings>): CacheFactorySettings;
+}