@daiso-tech/core 0.16.0 → 0.17.4

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

@@ -2,61 +2,75 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
+import type { IDeinitizable } from "../../../../utilities/_module";
 import { type TimeSpan, type IInitizable, type OneOrMore } from "../../../../utilities/_module";
-import type { ObjectId } from "mongodb";
-import { type Collection } from "mongodb";
-import type { ISerde } from "../../../../serde/contracts/_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;
-    group: string;
-    value: number | string;
-    expiresAt: Date | null;
-};
-/**
- * @group Adapters
- */
-export type MongodbCacheAdapterSettings = {
-    serde: ISerde<string>;
-    rootGroup: OneOrMore<string>;
-};
-/**
- * To utilize the <i>MongodbCacheAdapter</i>, you must install the <i>"mongodb"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { MongodbCacheAdapter, SuperJsonSerde } 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 serde = new SuperJsonSerde();
- * const cacheAdapter = new MongodbCacheAdapter(cacheCollection, {
- *   serde,
- *   rootGroup: "@global"
- * });
- *
- * (async () => {
- *   // 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 readonly mongodbSerde;
     private readonly group;
-    private readonly serde;
-    constructor(collection: Collection<MongodbCacheDocument>, { serde, rootGroup }: MongodbCacheAdapterSettings);
+    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>;

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

@@ -7,7 +7,7 @@ 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>;

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

@@ -4,42 +4,57 @@
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import type { OneOrMore } from "../../../../utilities/_module";
 import { type TimeSpan } from "../../../../utilities/_module";
-import { type Redis, type Result } from "ioredis";
-import type { ISerde } from "../../../../serde/contracts/_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_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 = {
-    serde: ISerde<string>;
-    rootGroup: OneOrMore<string>;
-};
-/**
- * To utilize the <i>RedisCacheAdapter</i>, you must install the <i>"ioredis"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { RedisCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
- * import Redis from "ioredis";
- *
- * const client = new Redis("YOUR_REDIS_CONNECTION_STRING");
- * const serde = new SuperJsonSerde();
- * const cacheAdapter = new RedisCacheAdapter(client, {
- *   serde,
- *   rootGroup: "@global"
- * });
- * ```
- */
-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 readonly serde;
+    private readonly baseSerde;
+    private readonly redisSerde;
     private readonly group;
-    constructor(client: Redis, { serde, rootGroup }: RedisCacheAdapterSettings);
+    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>;

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,52 +2,64 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { ISerde } from "../../../../serde/contracts/_module";
 import type { TimeSpan, IInitizable, IDeinitizable, OneOrMore } from "../../../../utilities/_module";
-import { type Database } from "better-sqlite3";
+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;
-    serde: ISerde<string>;
-    enableTransactions?: boolean;
-    expiredKeysRemovalInterval?: TimeSpan;
-    shouldRemoveExpiredKeys?: boolean;
-    rootGroup: OneOrMore<string>;
-};
-/**
- * To utilize the <i>SqliteCacheAdapter</i>, you must install the <i>"better-sqlite3"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { SqliteCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
- * import Sqlite from "better-sqlite3";
- *
- * const client = new Sqlite("local.db");
- * const serde = new SuperJsonSerde();
- * const cacheAdapter = new SqliteCacheAdapter(client, {
- *   serde,
- *   rootGroup: "@global"
- * });
- *
- * (async () => {
- *   // 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>;

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

@@ -1,2 +1,4 @@
-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;
+}

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

@@ -1,50 +1,70 @@
 /**
  * @module Cache
  */
-import type { IGroupableEventBus } from "../../../event-bus/contracts/_module";
-import type { ICacheFactory, IGroupableCache, ICacheAdapter } from "../../../cache/contracts/_module";
-import type { TimeSpan } from "../../../utilities/_module";
+import type { ICacheFactory, IGroupableCache } from "../../../cache/contracts/_module";
+import type { CacheFactorySettings } from "../../../cache/implementations/derivables/cache-factory-settings";
+import { CacheFactorySettingsBuilder } from "../../../cache/implementations/derivables/cache-factory-settings";
 /**
  * @group Derivables
  */
-export type CacheDrivers<TDrivers extends string> = Partial<Record<TDrivers, ICacheAdapter<any>>>;
-/**
- * @group Derivables
- */
-export type CacheFactorySettings<TDrivers extends string = string> = {
-    drivers: CacheDrivers<TDrivers>;
-    defaultDriver?: NoInfer<TDrivers>;
+export declare class CacheFactory<TAdapters extends string = string> implements ICacheFactory<TAdapters> {
     /**
-     * You can decide the default ttl value. If null is passed then no ttl will be used by default.
+     * @example
+     * ```ts
+     * import { CacheFactory, SuperJsonSerde. MemoryCacheAdapter, RedisCacheAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const cacheFactory = new CacheFactory(
+     *   CacheFactory
+     *     .settings()
+     *     .setEventBus(new EventBus(new MemoryEventBusAdapter({ rootGroup: "@global" })))
+     *     .setAdapter("memory", new MemoryCacheAdapter({
+     *       rootGroup: "@global"
+     *     }))
+     *     .setAdapter("redis", new RedisCacheAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde: new SuperJsonSerde(),
+     *       rootGroup: "@global"
+     *     }))
+     *     .setDefaultAdapter("memory")
+     *     .build()
+     * );
+     * ```
      */
-    defaultTtl?: TimeSpan;
+    static settings<TAdapters extends string, TSettings extends CacheFactorySettings<TAdapters>>(): CacheFactorySettingsBuilder<TSettings>;
+    private readonly adapters;
+    private readonly defaultAdapter?;
+    private readonly eventBus?;
+    private readonly defaultTtl;
+    private readonly retryAttempts?;
+    private readonly backoffPolicy?;
+    private readonly retryPolicy?;
+    private readonly timeout?;
     /**
-     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     * @example
+     * ```ts
+     * import { CacheFactory, MemoryCacheAdapter, RedisCacheAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis"
+     *
+     * const eventBus = new EventBus({
+     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * });
+     * const cacheFactory = new CacheFactory({
+     *   adapters: {
+     *     memory: new MemoryCacheAdapter({
+     *       rootGroup: "@global"
+     *     }),
+     *     redis: new RedisCacheAdapter({
+     *       client: new Redis("YOUR_REDIS_CONNECTION"),
+     *       serde: new SuperJsonSerde(),
+     *       rootGroup: "@global"
+     *     }),
+     *   },
+     *   defaultAdapter: "memory",
+     *   eventBus,
+     * });
+     * ```
      */
-    eventBus?: IGroupableEventBus<any>;
-};
-/**
- * @group Derivables
- * @example
- * ```ts
- * import { CacheFactory } from "@daiso-tech/core";
- * import Redis from "ioredis"
- *
- * const cacheFactory = new CacheFactory({
- *   drivers: {
- *     memory: new MemoryCacheAdapter(),
- *     redis: new RedisCacheAdapter(new Redis()),
- *   },
- *   defaultDriver: "memory",
- * });
- * ```
- */
-export declare class CacheFactory<TDrivers extends string = string, TType = unknown> implements ICacheFactory<TDrivers, TType> {
-    private readonly drivers;
-    private readonly defaultDriver?;
-    private readonly eventBus?;
-    private defaultTtl;
-    constructor(settings: CacheFactorySettings<TDrivers>);
-    use(driverName?: TDrivers | undefined): IGroupableCache<TType>;
-    withType<TOutput extends TType = TType>(): ICacheFactory<TDrivers, TOutput>;
+    constructor(settings: CacheFactorySettings<TAdapters>);
+    use<TType = unknown>(adapterName?: TAdapters | undefined): IGroupableCache<TType>;
 }