@daiso-tech/core 0.15.0 → 0.16.0

package/dist/types/cache/contracts/cache-factory.contract.d.ts

@@ -1,9 +1,9 @@
 /**
  * @module Cache
  */
-import type { INamespacedCache } from "../../cache/contracts/cache.contract";
+import type { IGroupableCache } from "../../cache/contracts/cache.contract";
 /**
- * The <i>ICacheFactory</i> contract makes it easy to configure and switch between different <i>{@link INamespacedCache}</i> dynamically.
+ * The <i>ICacheFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableCache}</i> dynamically.
  * @group Contracts
  */
 export type ICacheFactory<TDrivers extends string = string, TType = unknown> = {
@@ -28,12 +28,12 @@ export type ICacheFactory<TDrivers extends string = string, TType = unknown> = {
      * }
      * ```
      */
-    use(driverName?: TDrivers): INamespacedCache<TType>;
+    use(driverName?: TDrivers): IGroupableCache<TType>;
     /**
      * The <i>withTypes</i> method is used to set the value types of the cache.
      * @example
      * ```ts
-     * import { type ICacheFactory zodValidator } from "@daiso-tech/core";
+     * import { type ICacheFactory } from "@daiso-tech/core";
      *
      * async function main(cacheFactory: ICacheFactory): Promise<void> {
      *   await cacheFactory

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

@@ -83,12 +83,14 @@ export type ICache<TType = unknown> = ICacheListenable & {
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
     /**
-     * The <i>put</i> method replaces the key with given <i>value</i> if found. If the <i>key</i> is not found it will just be added. True is returned if the key is found otherwise false will be returned.
-     * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
+     * The <i>put</i> method replaces a <i>key</i> if the <i>key</i> exists including the ttl value or adds <i>key</i> that do not exists with a given <i>ttl</i>.
+     * Returns true if the <i>key</i> where replaced otherwise false is returned.
+     * You must provide a <i>ttl</i> value. If null is passed, the item will not expire.
      */
     put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
     /**
-     * The <i>putMany</i> method replaces the keys that exists. Adds keys that do not exists. Returns true for all the keys that where updated otherwise false is returned.
+     * The <i>putMany</i> method replaces the keys that exists including their ttl values or adds keys that do not exists.
+     * Returns true for all the keys that where replaced otherwise false is returned.
      */
     putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
     /**
@@ -127,42 +129,43 @@ export type ICache<TType = unknown> = ICacheListenable & {
      */
     clear(): LazyPromise<void>;
     /**
-     * The <i>getNamespace</i> method returns the complete namespace.
+     * The <i>getGroup</i> method returns the group name.
      * @example
      * ```ts
      * import type { ICache } from "@daiso-tech/core";
      *
      * async function main(cache: ICache) {
-     *   // Will be "@root"
-     *   console.log(cache.getNamespace())
+     *   // Will be "@global"
+     *   console.log(cache.getGroup())
      *
-     *   const cacheA = cache.withNamespace("a");
+     *   const cacheA = cache.withGroup("a");
      *
-     *   // Will be "@root/a"
-     *   console.log(cacheA.getNamespace())
+     *   // Will be "@global/a"
+     *   console.log(cacheA.getGroup())
      * }
      * ```
      */
-    getNamespace(): string;
+    getGroup(): string;
 };
 /**
- * The <i>INamespacedCache</i> contract defines a way for storing data as key-value pairs independent of data storage.
+ * The <i>IGroupableCache</i> contract defines a way for storing data as key-value pairs independent of data storage.
  * It commes with one extra method which is useful for multitennat applications compared to <i>ICache</i>.
  * @group Contracts
  */
-export type INamespacedCache<TType = unknown> = ICache<TType> & {
+export type IGroupableCache<TType = unknown> = ICache<TType> & {
     /**
-     * The <i>withNamespace</i> method returns new instance of <i>{@link ICache}</i> where all the keys will be prefixed with a given <i>namespace</i>.
+     * The <i>withGroup</i> method returns a new <i>{@link ICache}</i> instance that groups keys together.
+     * Only keys in the group can be updated, removed, or retrieved, leaving keys outside the group unaffected.
      * This useful for multitennat applications.
      * @example
      * ```ts
      * import { type ICache } from "@daiso-tech/core";
      *
      * async function main(cache: ICache): Promise<void> {
-     *   const cacheA = cache.withNamespace("a");
+     *   const cacheA = cache.withGroup("a");
      *   await cacheA.add("a", 1);
      *
-     *   const cacheB = cache.withNamespace("b");
+     *   const cacheB = cache.withGroup("b");
      *   await cacheB.add("b", 2);
      *
      *   // Will print { a: 1, b: null }
@@ -170,5 +173,5 @@ export type INamespacedCache<TType = unknown> = ICache<TType> & {
      * }
      * ```
      */
-    withNamespace(namespace: OneOrMore<string>): ICache<TType>;
+    withGroup(group: OneOrMore<string>): ICache<TType>;
 };

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

@@ -2,46 +2,42 @@
  * @module Cache
  */
 import type { TimeSpan } from "../../utilities/_module";
-import type { ICacheAdapter } from "../../cache/contracts/cache-adapter.contract";
-/**
- * @group Events
- */
-export type CacheEvent = {
-    namespace: string;
-    adapter: ICacheAdapter<any>;
-};
-/**
- * This event will be triggered when cache is cleared.
- * @group Events
- */
-export type KeysClearedCacheEvent = CacheEvent & {};
 export type CacheEvents<TType = unknown> = {
-    key_found: CacheEvent & {
+    key_found: {
+        group: string;
         key: string;
         value: TType;
     };
-    key_not_found: CacheEvent & {
+    key_not_found: {
+        group: string;
         key: string;
     };
-    key_added: CacheEvent & {
+    key_added: {
+        group: string;
         key: string;
         value: TType;
         ttl: TimeSpan | null;
     };
-    key_updated: CacheEvent & {
+    key_updated: {
+        group: string;
         key: string;
         value: TType;
     };
-    key_removed: CacheEvent & {
+    key_removed: {
+        group: string;
         key: string;
     };
-    key_incremented: CacheEvent & {
+    key_incremented: {
+        group: string;
         key: string;
         value: number;
     };
-    key_decremented: CacheEvent & {
+    key_decremented: {
+        group: string;
         key: string;
         value: number;
     };
-    keys_cleared: CacheEvent;
+    keys_cleared: {
+        group: string;
+    };
 };

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

@@ -12,7 +12,8 @@ export type CacheAdapterTestSuiteSettings = {
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createAdapter: () => Promisable<ICacheAdapter>;
+    createAdapterA: () => Promisable<ICacheAdapter>;
+    createAdapterB: () => Promisable<ICacheAdapter>;
 };
 /**
  * The <i>cacheAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICacheAdapter}</i> with <i>vitest</i>.
@@ -22,13 +23,13 @@ export type CacheAdapterTestSuiteSettings = {
  * import Redis from "ioredis";
  * import { afterEach, beforeEach, describe, expect, test } from "vitest";
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
- * import { SuperJsonSerializer, TimeSpan, RedisCacheAdapter, cacheAdapterTestSuite } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheAdapterTestSuite } from "@daiso-tech/core";
  *
  * const timeout = TimeSpan.fromMinutes(2);
  * describe("class: RedisCacheAdapter", () => {
  *   let client: Redis;
  *   let startedContainer: StartedRedisContainer;
- *   const serializer = new SuperJsonSerializer();
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer("redis:7.4.2").start();
  *     client = new Redis(startedContainer.getConnectionUrl());
@@ -38,9 +39,15 @@ export type CacheAdapterTestSuiteSettings = {
  *     await startedContainer.stop();
  *   }, timeout.toMilliseconds());
  *   cacheAdapterTestSuite({
- *     createAdapter: () =>
+ *     createAdapterA: () =>
  *       new RedisCacheAdapter(client, {
- *         serializer,
+ *         serde,
+ *         rootGroup: "@a"
+ *       }),
+ *     createAdapterB: () =>
+ *       new RedisCacheAdapter(client, {
+ *         serde,
+ *         rootGroup: "@b"
  *       }),
  *     test,
  *     beforeEach,

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

@@ -23,14 +23,14 @@ export type CacheTestSuiteSettings = {
  * import Redis from "ioredis";
  * import { afterEach, beforeEach, describe, expect, test } from "vitest";
  * import { RedisContainer, type StartedRedisContainer } from "@testcontainers/redis";
- * import { SuperJsonSerializer, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
+ * import { SuperJsonSerde, TimeSpan, RedisCacheAdapter, cacheTestSuite, MemoryEventBusAdapter } from "@daiso-tech/core";
  *
  * const timeout = TimeSpan.fromMinutes(2);
  * describe("class: Cache", () => {
  *   let client: Redis;
  *   let startedContainer: StartedRedisContainer;
  *   const eventBus = new EventBus(new MemoryEventBusAdapter()):
- *   const serializer = new SuperJsonSerializer();
+ *   const serde = new SuperJsonSerde();
  *   beforeEach(async () => {
  *     startedContainer = await new RedisContainer("redis:7.4.2").start();
  *     client = new Redis(startedContainer.getConnectionUrl());
@@ -43,20 +43,20 @@ export type CacheTestSuiteSettings = {
  *     createCacheA: () =>
  *       new Cache(
  *         new RedisCacheAdapter(client, {
- *           serializer,
+ *           serde,
  *         }),
  *         {
- *           rootNamespace: "@a",
+ *           rootGroup: "@a",
  *           eventBus,
  *         }
  *       ),
  *     createCacheB: () =>
  *       new Cache(
  *         new RedisCacheAdapter(client, {
- *           serializer,
+ *           serde,
  *         }),
  *         {
- *           rootNamespace: "@b",
+ *           rootGroup: "@b",
  *           eventBus,
  *         }
  *       ),

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

@@ -3,13 +3,14 @@
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/_module";
 import { type Kysely } from "kysely";
-import { type ISerializer } from "../../../../serializer/contracts/_module";
-import type { IDeinitizable, IInitizable } from "../../../../utilities/_module";
+import { type ISerde } from "../../../../serde/contracts/_module";
+import type { IDeinitizable, IInitizable, OneOrMore } from "../../../../utilities/_module";
 import { TimeSpan } from "../../../../utilities/_module";
 /**
  * @internal
  */
 type KyselySqliteCacheTable = {
+    group: string;
     key: string;
     value: string;
     expiresAt: number | null;
@@ -24,32 +25,37 @@ type KyselySqliteTables = {
  * @internal
  */
 type KyselySqliteSettings = {
-    serializer: ISerializer<string>;
+    serde: ISerde<string>;
     enableTransactions: boolean;
     expiredKeysRemovalInterval?: TimeSpan;
     shouldRemoveExpiredKeys?: boolean;
+    rootGroup: OneOrMore<string>;
 };
 /**
  * @internal
  */
 export declare class KyselySqliteCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly db;
-    private readonly serializer;
+    private readonly group;
+    private readonly serde;
     private readonly enableTransactions;
     private readonly expiredKeysRemovalInterval;
     private readonly shouldRemoveExpiredKeys;
     private timeoutId;
     constructor(db: Kysely<KyselySqliteTables>, settings: KyselySqliteSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     private withTransaction;
     removeExpiredKeys(): Promise<void>;
     init(): Promise<void>;
     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>;
 }
 export {};

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

@@ -2,33 +2,36 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
-import type { TimeSpan, IDeinitizable, IInitizable } from "../../../../utilities/_module";
+import type { ISerde } from "../../../../serde/contracts/_module";
+import type { TimeSpan, IDeinitizable, IInitizable, OneOrMore } from "../../../../utilities/_module";
 import type { Client } from "@libsql/client";
 /**
  * @group Adapters
  */
 export type LibsqlCacheAdapterSettings = {
     tableName?: string;
-    serializer: ISerializer<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 ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
+ * 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, SuperJsonSerializer } from "@daiso-tech/core";
+ * 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 () => {
- *   const client = createClient({ url: "file:local.db" });
- *   const serializer = new SuperJsonSerializer();
- *   const cacheAdapter = new LibsqlCacheAdapter(client, {
- *     serializer,
- *   });
  *   // You only need to call it once before using the adapter.
  *   await cacheAdapter.init();
  *   await cacheAdapter.add("a", 1);
@@ -41,14 +44,17 @@ export type LibsqlCacheAdapterSettings = {
 export declare class LibsqlCacheAdapter<TType> implements ICacheAdapter<TType>, IInitizable, IDeinitizable {
     private readonly cacheAdapter;
     constructor(client: Client, settings: LibsqlCacheAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     removeExpiredKeys(): Promise<void>;
     deInit(): Promise<void>;
     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/adapters/memory-cache-adapter/memory-cache-adapter.d.ts

@@ -2,7 +2,7 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan } from "../../../../utilities/_module";
+import { type OneOrMore, type TimeSpan } from "../../../../utilities/_module";
 /**
  * To utilize the <i>MemoryCacheAdapter</i>, you must create instance of it.
  * @group Adapters
@@ -18,18 +18,24 @@ import type { TimeSpan } from "../../../../utilities/_module";
  * import { MemoryCacheAdapter } from "@daiso-tech/core";
  *
  * const map = new Map<any, any>();
- * const cacheAdapter = new MemoryCacheAdapter(map);
+ * const cacheAdapter = new MemoryCacheAdapter("@cache", map);
  * ```
  */
 export declare class MemoryCacheAdapter<TType> implements ICacheAdapter<TType> {
     private readonly map;
-    constructor(map?: Map<string, TType>);
-    private readonly timeoutIdMap;
+    private readonly group;
+    private readonly timeoutMap;
+    constructor(rootGroup: OneOrMore<string>, map?: Map<string, TType>);
+    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>;
-    put(key: string, value: TType, _ttl: TimeSpan | null): 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>;
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
 }

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

@@ -2,16 +2,17 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan, IInitizable } 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 { ISerializer } from "../../../../serializer/contracts/_module";
+import type { ISerde } from "../../../../serde/contracts/_module";
 /**
  * @group Adapters
  */
 export type MongodbCacheDocument = {
     _id: ObjectId;
     key: string;
+    group: string;
     value: number | string;
     expiresAt: Date | null;
 };
@@ -19,39 +20,49 @@ export type MongodbCacheDocument = {
  * @group Adapters
  */
 export type MongodbCacheAdapterSettings = {
-    serializer: ISerializer<string>;
+    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 ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
+ * 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, SuperJsonSerializer } from "@daiso-tech/core";
+ * 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 serializer = new SuperJsonSerializer();
+ * const serde = new SuperJsonSerde();
  * const cacheAdapter = new MongodbCacheAdapter(cacheCollection, {
- *   serializer,
+ *   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;
     private static isMongodbIncrementError;
-    private serializer;
-    constructor(collection: Collection<MongodbCacheDocument>, { serializer }: MongodbCacheAdapterSettings);
+    private readonly mongodbSerde;
+    private readonly group;
+    private readonly serde;
+    constructor(collection: Collection<MongodbCacheDocument>, { serde, rootGroup }: MongodbCacheAdapterSettings);
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): ICacheAdapter<TType>;
     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/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> {
+    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/redis-cache-adapter.d.ts

@@ -2,42 +2,47 @@
  * @module Cache
  */
 import { type ICacheAdapter } from "../../../../cache/contracts/cache-adapter.contract";
-import type { TimeSpan } from "../../../../utilities/_module";
+import type { OneOrMore } from "../../../../utilities/_module";
+import { type TimeSpan } from "../../../../utilities/_module";
 import { type Redis, type Result } from "ioredis";
-import type { ISerializer } from "../../../../serializer/contracts/_module";
+import type { ISerde } from "../../../../serde/contracts/_module";
 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>;
     }
 }
 /**
  * @group Adapters
  */
 export type RedisCacheAdapterSettings = {
-    serializer: ISerializer<string>;
+    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 ISerializer | string serializer}</i>, such as <i>{@link SuperJsonSerializer}</i>.
+ * 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, SuperJsonSerializer } from "@daiso-tech/core";
+ * import { RedisCacheAdapter, SuperJsonSerde } from "@daiso-tech/core";
  * import Redis from "ioredis";
  *
  * const client = new Redis("YOUR_REDIS_CONNECTION_STRING");
- * const serializer = new SuperJsonSerializer();
+ * const serde = new SuperJsonSerde();
  * const cacheAdapter = new RedisCacheAdapter(client, {
- *   serializer,
+ *   serde,
+ *   rootGroup: "@global"
  * });
  * ```
  */
 export declare class RedisCacheAdapter<TType> implements ICacheAdapter<TType> {
     private readonly client;
     private static isRedisTypeError;
-    private serializer;
-    constructor(client: Redis, { serializer }: RedisCacheAdapterSettings);
+    private readonly serde;
+    private readonly group;
+    constructor(client: Redis, { 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 +50,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>;
 }