@daiso-tech/core 0.16.0 → 0.17.4

package/dist/types/cache/contracts/cache.events.d.ts

@@ -1,43 +1,161 @@
 /**
  * @module Cache
  */
+import { BaseEvent } from "../../event-bus/contracts/_module";
+import type { IFlexibleSerde } from "../../serde/contracts/_module";
 import type { TimeSpan } from "../../utilities/_module";
-export type CacheEvents<TType = unknown> = {
-    key_found: {
-        group: string;
-        key: string;
-        value: TType;
-    };
-    key_not_found: {
-        group: string;
-        key: string;
-    };
-    key_added: {
-        group: string;
-        key: string;
-        value: TType;
-        ttl: TimeSpan | null;
-    };
-    key_updated: {
-        group: string;
-        key: string;
-        value: TType;
-    };
-    key_removed: {
-        group: string;
-        key: string;
-    };
-    key_incremented: {
-        group: string;
-        key: string;
-        value: number;
-    };
-    key_decremented: {
-        group: string;
-        key: string;
-        value: number;
-    };
-    keys_cleared: {
-        group: string;
-    };
+/**
+ * @group Events
+ */
+export type KeyFoundCacheEventFields<TType> = {
+    group: string;
+    key: string;
+    value: TType;
+};
+/**
+ * @group Events
+ */
+export declare class KeyFoundCacheEvent<TType = unknown> extends BaseEvent<KeyFoundCacheEventFields<TType>> {
+    group: string;
+    key: string;
+    value: TType;
+    static deserialize<TType>(serializedEvent: KeyFoundCacheEventFields<TType>): KeyFoundCacheEvent<TType>;
+    constructor(fields: KeyFoundCacheEventFields<TType>);
+    serialize(): KeyFoundCacheEventFields<TType>;
+}
+/**
+ * @group Events
+ */
+export type KeyNotFoundCacheEventFields = {
+    group: string;
+    key: string;
+};
+/**
+ * @group Events
+ */
+export declare class KeyNotFoundCacheEvent extends BaseEvent<KeyNotFoundCacheEventFields> {
+    group: string;
+    key: string;
+    static deserialize(serializedEvent: KeyNotFoundCacheEventFields): KeyNotFoundCacheEvent;
+    constructor(fields: KeyNotFoundCacheEventFields);
+    serialize(): KeyNotFoundCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeyAddedCacheEventFields<TType = unknown> = {
+    group: string;
+    key: string;
+    value: TType;
+    ttl: TimeSpan | null;
+};
+/**
+ * @group Events
+ */
+export declare class KeyAddedCacheEvent<TType = unknown> extends BaseEvent<KeyAddedCacheEventFields<TType>> {
+    group: string;
+    key: string;
+    value: TType;
+    ttl: TimeSpan | null;
+    static deserialize<TType>(serializedEvent: KeyAddedCacheEventFields<TType>): KeyAddedCacheEvent<TType>;
+    constructor(fields: KeyAddedCacheEventFields<TType>);
+    serialize(): KeyAddedCacheEventFields<TType>;
+}
+/**
+ * @group Events
+ */
+export type KeyUpdatedCacheEventFields<TType = unknown> = {
+    group: string;
+    key: string;
+    value: TType;
+};
+/**
+ * @group Events
+ */
+export declare class KeyUpdatedCacheEvent<TType = unknown> extends BaseEvent<KeyUpdatedCacheEventFields<TType>> {
+    group: string;
+    key: string;
+    value: TType;
+    static deserialize<TType>(serializedEvent: KeyUpdatedCacheEventFields<TType>): KeyUpdatedCacheEvent<TType>;
+    constructor(fields: KeyUpdatedCacheEventFields<TType>);
+    serialize(): KeyUpdatedCacheEventFields<TType>;
+}
+/**
+ * @group Events
+ */
+export type KeyRemovedCacheEventFields = {
+    group: string;
+    key: string;
 };
+/**
+ * @group Events
+ */
+export declare class KeyRemovedCacheEvent extends BaseEvent<KeyRemovedCacheEventFields> {
+    group: string;
+    key: string;
+    static deserialize(serializedEvent: KeyRemovedCacheEventFields): KeyRemovedCacheEvent;
+    constructor(fields: KeyRemovedCacheEventFields);
+    serialize(): KeyRemovedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeyIncrementedCacheEventFields = {
+    group: string;
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export declare class KeyIncrementedCacheEvent extends BaseEvent<KeyIncrementedCacheEventFields> {
+    group: string;
+    key: string;
+    value: number;
+    static deserialize(serializedEvent: KeyIncrementedCacheEventFields): KeyIncrementedCacheEvent;
+    constructor(fields: KeyIncrementedCacheEventFields);
+    serialize(): KeyIncrementedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeyDecrementedCacheEventFields = {
+    group: string;
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export declare class KeyDecrementedCacheEvent extends BaseEvent<KeyDecrementedCacheEventFields> {
+    group: string;
+    key: string;
+    value: number;
+    static deserialize(serializedEvent: KeyDecrementedCacheEventFields): KeyDecrementedCacheEvent;
+    constructor(fields: KeyDecrementedCacheEventFields);
+    serialize(): KeyDecrementedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type KeysClearedCacheEventFields = {
+    group: string;
+};
+/**
+ * @group Events
+ */
+export declare class KeysClearedCacheEvent extends BaseEvent<KeysClearedCacheEventFields> {
+    group: string;
+    static deserialize(serializedEvent: KeysClearedCacheEventFields): KeysClearedCacheEvent;
+    constructor(fields: KeysClearedCacheEventFields);
+    serialize(): KeysClearedCacheEventFields;
+}
+/**
+ * @group Events
+ */
+export type CacheEvents<TType = unknown> = KeyFoundCacheEvent<TType> | KeyNotFoundCacheEvent | KeyAddedCacheEvent<TType> | KeyUpdatedCacheEvent<TType> | KeyRemovedCacheEvent | KeyIncrementedCacheEvent | KeyDecrementedCacheEvent | KeysClearedCacheEvent;
+/**
+ * The <i>registerCacheEvents</i> function is used to register all cache events with a <i>{@link IFlexibleSerde}</i>.
+ * @group Events
+ */
+export declare function registerCacheEvents<TSerializedValue>(serde: IFlexibleSerde<TSerializedValue>): void;

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

@@ -1 +1,2 @@
 export * from "../../../cache/implementations/_shared/cache-adapter.test-suite";
+export * from "../../../cache/implementations/_shared/cache.test-suite";

package/dist/types/cache/implementations/_shared/cache-adapter.test-suite.d.ts

@@ -25,27 +25,29 @@ export type CacheAdapterTestSuiteSettings = {
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
  * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheAdapterTestSuite } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: RedisCacheAdapter", () => {
- *   let client: Redis;
+ *   let database: Redis;
  *   let startedContainer: StartedRedisContainer;
  *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer("redis:7.4.2").start();
- *     client = new Redis(startedContainer.getConnectionUrl());
- *   }, timeout.toMilliseconds());
+ *     database = new Redis(startedContainer.getConnectionUrl());
+ *   }, TIMEOUT.toMilliseconds());
  *   afterEach(async () => {
- *     await client.quit();
+ *     await database.quit();
  *     await startedContainer.stop();
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *   cacheAdapterTestSuite({
  *     createAdapterA: () =>
- *       new RedisCacheAdapter(client, {
+ *       new RedisCacheAdapter({
+ *         database,
  *         serde,
  *         rootGroup: "@a"
  *       }),
  *     createAdapterB: () =>
- *       new RedisCacheAdapter(client, {
+ *       new RedisCacheAdapter({
+ *         database,
  *         serde,
  *         rootGroup: "@b"
  *       }),

package/dist/types/cache/implementations/_shared/cache.test-suite.d.ts

@@ -25,24 +25,29 @@ export type CacheTestSuiteSettings = {
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
  * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
  *
- * const timeout = TimeSpan.fromMinutes(2);
+ * const TIMEOUT = TimeSpan.fromMinutes(2);
  * describe("class: Cache", () => {
- *   let client: Redis;
+ *   let database: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const eventBus = new EventBus(new MemoryEventBusAdapter()):
+ *   const eventBus = new EventBus({
+ *     adapter: new MemoryEventBusAdapter({
+ *       rootGroup: "@global"
+ *     })
+ *   }):
  *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer("redis:7.4.2").start();
- *     client = new Redis(startedContainer.getConnectionUrl());
- *   }, timeout.toMilliseconds());
+ *     database = new Redis(startedContainer.getConnectionUrl());
+ *   }, TIMEOUT.toMilliseconds());
  *   afterEach(async () => {
- *     await client.quit();
+ *     await database.quit();
  *     await startedContainer.stop();
- *   }, timeout.toMilliseconds());
+ *   }, TIMEOUT.toMilliseconds());
  *   cacheTestSuite({
  *     createCacheA: () =>
  *       new Cache(
- *         new RedisCacheAdapter(client, {
+ *         new RedisCacheAdapter({
+ *           database,
  *           serde,
  *         }),
  *         {
@@ -52,7 +57,8 @@ export type CacheTestSuiteSettings = {
  *       ),
  *     createCacheB: () =>
  *       new Cache(
- *         new RedisCacheAdapter(client, {
+ *         new RedisCacheAdapter({
+ *           database,
  *           serde,
  *         }),
  *         {

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

@@ -25,6 +25,7 @@ type KyselySqliteTables = {
  * @internal
  */
 type KyselySqliteSettings = {
+    db: Kysely<KyselySqliteTables>;
     serde: ISerde<string>;
     enableTransactions: boolean;
     expiredKeysRemovalInterval?: TimeSpan;
@@ -34,15 +35,15 @@ type KyselySqliteSettings = {
 /**
  * @internal
  */
-export declare class KyselySqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
-    private readonly db;
+export declare class KyselySqliteCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly group;
     private readonly serde;
     private readonly enableTransactions;
     private readonly expiredKeysRemovalInterval;
     private readonly shouldRemoveExpiredKeys;
     private timeoutId;
-    constructor(db: Kysely<KyselySqliteTables>, settings: KyselySqliteSettings);
+    private readonly db;
+    constructor(settings: KyselySqliteSettings);
     getGroup(): string;
     withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     private withTransaction;

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

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

package/dist/types/cache/implementations/adapters/libsql-cache-adapter/libsql-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 { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlCacheAdapterSettings = {
+    database: Client;
+    tableName?: string;
+    serde: ISerde<string>;
+    enableTransactions?: boolean;
+    expiredKeysRemovalInterval?: TimeSpan;
+    shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
+};
+/**
+ * The <i>LibsqlCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class LibsqlCacheAdapterSettingsBuilder<TSettings extends Partial<LibsqlCacheAdapterSettings>> implements IBuildable<LibsqlCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setDatabase(database: Client): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        database: Client;
+    }>;
+    setTableName(name: string): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        tableName: string;
+    }>;
+    setSerde(serde: ISerde<string>): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        serde: ISerde<string>;
+    }>;
+    setEnableTransactions(enable: boolean): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        enableTransactions: boolean;
+    }>;
+    setExpiredKeysRemovalInterval(interval: TimeSpan): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        expiredKeysRemovalInterval: TimeSpan;
+    }>;
+    setShouldRemoveExpiredKeys(shouldRemove: boolean): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        shouldRemoveExpiredKeys: boolean;
+    }>;
+    setRootGroup(group: OneOrMore<string>): LibsqlCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: LibsqlCacheAdapterSettingsBuilder<LibsqlCacheAdapterSettings>): LibsqlCacheAdapterSettings;
+}

package/dist/types/cache/implementations/adapters/libsql-cache-adapter/libsql-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, IDeinitizable, IInitizable, OneOrMore } from "../../../../utilities/_module";
-import type { Client } from "@libsql/client";
+import type { LibsqlCacheAdapterSettings } from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
+import { LibsqlCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/libsql-cache-adapter/libsql-cache-adapter-settings";
 /**
+ * To utilize the <i>LibsqlCacheAdapter</i>, you must install the <i>"@libsql/client"</i> package and supply a <i>{@link ISerde | ISerde<string> }</i>, such as <i>{@link SuperJsonSerde}</i>.
  * @group Adapters
  */
-export type LibsqlCacheAdapterSettings = {
-    tableName?: string;
-    serde: ISerde<string>;
-    enableTransactions?: boolean;
-    expiredKeysRemovalInterval?: TimeSpan;
-    shouldRemoveExpiredKeys?: boolean;
-    rootGroup: OneOrMore<string>;
-};
-/**
- * To utilize the <i>LibsqlCacheAdapter</i>, you must install the <i>"@libsql/client"</i> package and supply a <i>{@link ISerde | string serde}</i>, such as <i>{@link SuperJsonSerde}</i>.
- * @group Adapters
- * @example
- * ```ts
- * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
- * import { createClient } from "@libsql/client";
- *
- * const client = createClient({ url: "file:local.db" });
- * const serde = new SuperJsonSerde();
- * const cacheAdapter = new LibsqlCacheAdapter(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 LibsqlCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+export declare class LibsqlCacheAdapter<TType = unknown> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
+    /**
+     * @example
+     * ```ts
+     * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { createClient } from "@libsql/client";
+     *
+     * const cacheAdapter = new LibsqlCacheAdapter(
+     *   LibsqlCacheAdapter
+     *     .settings()
+     *     .setDatabase(createClient({ url: "file:local.db" }))
+     *     .setSerde(new SuperJsonSerde())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<LibsqlCacheAdapterSettings>>(): LibsqlCacheAdapterSettingsBuilder<TSettings>;
     private readonly cacheAdapter;
-    constructor(client: Client, settings: LibsqlCacheAdapterSettings);
+    /***
+     * @example
+     * ```ts
+     * import { LibsqlCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     * import { createClient } from "@libsql/client";
+     *
+     * const database = createClient({ url: "file:local.db" });
+     * const serde = new SuperJsonSerde();
+     * const cacheAdapter = new LibsqlCacheAdapter({
+     *   database,
+     *   serde,
+     *   rootGroup: "@global"
+     * });
+     *
+     * (async () => {
+     *   await cacheAdapter.init();
+     *   await cacheAdapter.add("a", 1);
+     *   await cacheAdapter.deInit();
+     * })();
+     * ```
+     */
+    constructor(settings: LibsqlCacheAdapterSettings);
     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/adapters/memory-cache-adapter/_module.d.ts

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

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

@@ -0,0 +1,27 @@
+/**
+ * @module Cache
+ */
+import type { IBuildable } from "../../../../utilities/_module";
+import { type OneOrMore } from "../../../../utilities/_module";
+/**
+ * @group Adapters
+ */
+export type MemoryCacheAdapterSettings = {
+    rootGroup: OneOrMore<string>;
+    map?: Map<string, unknown>;
+};
+/**
+ * The <i>MemoryCacheAdapterSettingsBuilder</i> is an immutable builder class, meaning that each method invocation creates a new instance.
+ * @group Adapters
+ */
+export declare class MemoryCacheAdapterSettingsBuilder<TSettings extends Partial<MemoryCacheAdapterSettings>> implements IBuildable<MemoryCacheAdapterSettings> {
+    private readonly settings;
+    constructor(settings?: TSettings);
+    setMap(map: Map<string, unknown>): MemoryCacheAdapterSettingsBuilder<TSettings & {
+        map: Map<string, unknown>;
+    }>;
+    setRootGroup(group: OneOrMore<string>): MemoryCacheAdapterSettingsBuilder<TSettings & {
+        rootGroup: OneOrMore<string>;
+    }>;
+    build(this: MemoryCacheAdapterSettingsBuilder<MemoryCacheAdapterSettings>): MemoryCacheAdapterSettings;
+}

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

@@ -3,29 +3,53 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
 import { type OneOrMore, type TimeSpan } from "../../../../utilities/_module";
+import type { MemoryCacheAdapterSettings } from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
+import { MemoryCacheAdapterSettingsBuilder } from "../../../../cache/implementations/adapters/memory-cache-adapter/memory-cache-adapter-settings";
 /**
  * To utilize the <i>MemoryCacheAdapter</i>, you must create instance of it.
  * @group Adapters
- * @example
- * ```ts
- * import { MemoryCacheAdapter } from "@daiso-tech/core";
- *
- * const cacheAdapter = new MemoryCacheAdapter(client);
- * ```
- * You can also provide an <i>Map</i>.
- * @example
- * ```ts
- * import { MemoryCacheAdapter } from "@daiso-tech/core";
- *
- * const map = new Map<any, any>();
- * const cacheAdapter = new MemoryCacheAdapter("@cache", map);
- * ```
  */
-export declare class MemoryCacheAdapter<TType> implements ICacheAdapter<TType> {
-    private readonly map;
+export declare class MemoryCacheAdapter<TType = unknown> implements ICacheAdapter<TType> {
+    /**
+     * @example
+     * ```ts
+     * import { MemoryCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
+     *
+     * const cacheAdapter = new MemoryCacheAdapter(
+     *   MemoryCacheAdapter
+     *     .settings()
+     *     .setMap(new Map())
+     *     .setRootGroup("@global")
+     *     .build()
+     * );
+     * ```
+     */
+    static settings<TSettings extends Partial<MemoryCacheAdapterSettings>>(): MemoryCacheAdapterSettingsBuilder<TSettings>;
     private readonly group;
     private readonly timeoutMap;
-    constructor(rootGroup: OneOrMore<string>, map?: Map<string, TType>);
+    private readonly map;
+    /**
+     *  @example
+     * ```ts
+     * import { MemoryCacheAdapter } from "@daiso-tech/core";
+     *
+     * const cacheAdapter = new MemoryCacheAdapter({
+     *   rootGroup: "@cache"
+     * });
+     * ```
+     * You can also provide an <i>Map</i>.
+     * @example
+     * ```ts
+     * import { MemoryCacheAdapter } from "@daiso-tech/core";
+     *
+     * const map = new Map<any, any>();
+     * const cacheAdapter = new MemoryCacheAdapter({
+     *   rootGroup: "@cache",
+     *   map
+     * });
+     * ```
+     */
+    constructor(settings: MemoryCacheAdapterSettings);
     private getGroupName;
     private withPrefix;
     exists(key: string): Promise<boolean>;

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;
+}