@daiso-tech/core 0.7.0 → 0.8.1

package/dist/types/storage/contracts/storage-adapter.contract.d.ts

@@ -2,52 +2,40 @@
  * @module Storage
  */
 /**
- * @throws {StorageError} {@link StorageError}
- * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
- * @throws {TypeStorageError} {@link TypeStorageError}
+ * The <i>IStorageAdapter</i> contract defines a way for storing data as key-value pairs independent of storage.
+ * This interface is not meant to be used directly, instead you should use <i>IStorage</i>
  * @group Contracts
  */
-export type IStorageAdapter<TType> = {
+export type IStorageAdapter<TType = unknown> = {
     /**
-     * Returns the value for the keys that are found otherwise null will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
      */
     getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
     /**
-     * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>addMany</i> method adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      */
     addMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>putMany</i> method replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      */
     putMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      */
     removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Will increment the existing key with value if found otherwise nonthing occurs. Returns true if key exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
+     * Returns true if key exists otherwise false will be returned.
+     * An error will thrown if the key is not a number.
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
     increment(key: string, value: number): PromiseLike<boolean>;
     /**
-     * @throws {StorageError} {@link StorageError}
-     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * The <i>clear</i> method removes all keys that starts <i>prefix</i>.
      */
     clear(prefix: string): PromiseLike<void>;
 };

package/dist/types/storage/contracts/storage-events.contract.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @module Storage
+ */
+import type { IStorageAdapter } from "../../storage/contracts/storage-adapter.contract";
+/**
+ * Name of all the events of <i>{@link IStorage}</i>.
+ * @group Events
+ */
+export declare const STORAGE_EVENTS: {
+    readonly KEYS_FOUND: "keys_found";
+    readonly KEYS_NOT_FOUND: "keys_not_found";
+    readonly KEYS_ADDED: "keys_added";
+    readonly KEYS_UPDATED: "keys_updated";
+    readonly KEYS_REMOVED: "keys_removed";
+    readonly KEYS_CLEARED: "keys_cleared";
+    readonly KEY_INCREMENTED: "key_incremented";
+    readonly KEY_DECREMENTED: "key_decremented";
+};
+/**
+ * @group Events
+ */
+export type StorageEventNames = (typeof STORAGE_EVENTS)[keyof typeof STORAGE_EVENTS];
+/**
+ * @group Events
+ */
+export type StorageEvent = {
+    namespace: string;
+    adapter: IStorageAdapter<any>;
+};
+/**
+ * @group Events
+ */
+export type KeysFoundStorageEvent<TType> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_FOUND"];
+    values: Record<string, TType>;
+};
+/**
+ * @group Events
+ */
+export type KeysNotFoundStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_NOT_FOUND"];
+    keys: string[];
+};
+/**
+ * @group Events
+ */
+export type KeysAddedStorageEvent<TType> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_ADDED"];
+    values: Record<string, TType>;
+};
+/**
+ * @group Events
+ */
+export type KeysUpdatedStorageEvent<TType> = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_UPDATED"];
+    values: Record<string, TType>;
+};
+/**
+ * @group Events
+ */
+export type KeyIncrementedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_INCREMENTED"];
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export type KeyDecrementedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEY_DECREMENTED"];
+    key: string;
+    value: number;
+};
+/**
+ * @group Events
+ */
+export type KeysRemovedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_REMOVED"];
+    keys: string[];
+};
+/**
+ * This event will be triggered when storage is cleared.
+ * @group Events
+ */
+export type KeysClearedStorageEvent = StorageEvent & {
+    type: (typeof STORAGE_EVENTS)["KEYS_CLEARED"];
+};
+/**
+ * @group Events
+ */
+export type AllStorageEvents<TType = unknown> = KeysFoundStorageEvent<TType> | KeysNotFoundStorageEvent | KeysAddedStorageEvent<TType> | KeysUpdatedStorageEvent<TType> | KeysRemovedStorageEvent | KeysClearedStorageEvent | KeyIncrementedStorageEvent | KeyDecrementedStorageEvent;

package/dist/types/storage/contracts/storage-manager.contract.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @module Storage
+ */
+import type { Validator } from "../../utilities/_module";
+import type { INamespacedStorage } from "../../storage/contracts/storage.contract";
+/**
+ * The <i>IStorageFactory</i> contract makes it easy to switch between different <i>{@link IStorageAdapter | storage adapters}</i> dynamically.
+ * @group Contracts
+ */
+export type IStorageFactory<TAdapters extends string = string, TType = unknown> = {
+    /**
+     * @example
+     * ```ts
+     * import { StorageManager, MemoryStorageAdapter, RedisStorageAdapter } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     *
+     * const storageManager = new StorageManager({
+     *   adapters: {
+     *     memory: new MemoryStorageAdapter(),
+     *     redis: new RedisStorageAdapter(new Redis()),
+     *   },
+     *   defaultAdapter: "memory",
+     *   rootNamespace: "@storage/"
+     * });
+     *
+     * (async () => {
+     *   // Will add key using the default adapter which is the memory addapter
+     *   await storageManager
+     *     .use()
+     *     .add("a", 1);
+     *   // Will add key using the redis addapter
+     *   await storageManager
+     *     .use("redis")
+     *     .add("a", 1);
+     * })();
+     * ```
+     */
+    use(adapter?: TAdapters): INamespacedStorage<TType>;
+};
+/**
+ * The <i>IStorageManager</i> contract makes it easy to configure and switch between different <i>{@link IStorageAdapter | storage adapters}</i> dynamically.
+ * @group Contracts
+ */
+export type IStorageManager<TAdapters extends string = string, TType = unknown> = IStorageFactory<TAdapters, TType> & {
+    /**
+     * The <i>withValidation</i> method is used to set a <i>validator</i>, which validates the storage values during runtime.
+     * The type is inferred from the provided <i>validator</i>.
+     * @example
+     * ```ts
+     * import { StorageManager, MemoryStorageAdapter, RedisStorageAdapter, zodValidator } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     * import { z } from "zod"
+     *
+     * const storageManager = new StorageManager({
+     *   adapters: {
+     *     memory: new MemoryStorageAdapter(),
+     *     redis: new RedisStorageAdapter(new Redis()),
+     *   },
+     *   defaultAdapter: "memory",
+     *   rootNamespace: "@storage/"
+     * });
+     *
+     * (async () => {
+     *   await storageManager
+     *     .withValidation(zodValidator(z.string()))
+     *     .use()
+     *     // You will se an typescript error and get runtime erorr
+     *     .add("a", 1);
+     * })();
+     * ```
+     */
+    withValidation<TOutput extends TType = TType>(validator: Validator<TOutput>): IStorageFactory<TAdapters, TOutput>;
+    /**
+     * The <i>withTypes</i> method is used to set the value types of the storage.
+     * @example
+     * ```ts
+     * import { StorageManager, MemoryStorageAdapter, RedisStorageAdapter, zodValidator } from "@daiso-tech/core";
+     * import Redis from "ioredis";
+     * import { z } from "zod"
+     *
+     * const storageManager = new StorageManager({
+     *   adapters: {
+     *     memory: new MemoryStorageAdapter(),
+     *     redis: new RedisStorageAdapter(new Redis()),
+     *   },
+     *   defaultAdapter: "memory",
+     *   rootNamespace: "@storage/"
+     * });
+     *
+     * (async () => {
+     *   await storageManager
+     *     .withTypes<string>()
+     *     .use()
+     *     // You will se an typescript error
+     *     .add("a", 1)
+     * })();
+     * ```
+     */
+    withType<TOutput extends TType = TType>(): IStorageFactory<TAdapters, TOutput>;
+};

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

@@ -1,151 +1,184 @@
 /**
  * @module Storage
  */
+import type { IListenable } from "../../event-bus/contracts/_module";
 import { type AnyFunction, type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
+import type { AllStorageEvents } from "../../storage/contracts/_module";
 export type StorageValue<T> = Exclude<T, AnyFunction | undefined | null>;
 /**
- * @throws {StorageError} {@link StorageError}
- * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
- * @throws {TypeStorageError} {@link TypeStorageError}
+ * The <i>IStorageListenable</i> contract defines a way for listening <i>{@link IStorage}</i> crud operations.
+ */
+export type IStorageListenable<TType = unknown> = IListenable<AllStorageEvents<TType>>;
+/**
+ * The <i>IStorage</i> contract defines a way for storing data as key-value pairs independent of storage.
+ * It commes with more convient methods compared to <i>IStorageAdapter</i>.
  * @group Contracts
  */
-export type IStorage<TType = unknown> = {
+export type IStorage<TType = unknown> = IStorageListenable & {
     /**
-     * Return a new instance of <i>IStorage</i> prefixed with given <i>name</i>
-     */
-    namespace(name: string): IStorage<TType>;
-    /**
-     * Returns true when key is found otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     exists(key: string): PromiseLike<boolean>;
     /**
-     * Returns true for the keys that are found otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>existsMany</i> method returns true for the <i>keys</i> that are found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Returns true when key is not found otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>missing</i> method returns true when <i>key</i> is not found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     missing(key: string): PromiseLike<boolean>;
     /**
-     * Returns true for the keys that are not found otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>missingMany</i> method returns true for the <i>keys</i> that are not found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Returns the value when key is found otherwise null will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>get</i> method returns the value when <i>key</i> is found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     get(key: string): PromiseLike<TType | null>;
     /**
-     * Returns the value for the keys that are found otherwise null will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
     /**
-     * Returns the value when key is found otherwise defaultValue will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>getOr</i> method returns the value when <i>key</i> is found otherwise <i>defaultValue</i> will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getOr(key: string, defaultValue: AsyncLazyable<TType>): PromiseLike<TType>;
     /**
-     * Returns the value for the keys that are found otherwise defaultValue will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>getOrMany</i> method returns the value for the keys that are found otherwise defaultValue will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): PromiseLike<Record<TKeys, TType>>;
     /**
-     * Returns the value when key is found otherwise an error will be thrown.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>getOrFail</i> method returns the value when <i>key</i> is found otherwise an error will be thrown.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
      */
     getOrFail(key: string): PromiseLike<TType>;
     /**
-     * Adds a key when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>add</i> method adds a <i>key</i> with given <i>value</i> when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     add(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
     /**
-     * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>addMany</i> method adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Updates a keys that exists. Returns true when key otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>update</i> method updates the given <i>key</i> with given <i>value</i>. Returns true when key otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     update(key: string, value: TType): PromiseLike<boolean>;
     /**
-     * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * If the key is found it will replaced. If the key is not found it will just be added. True is returned if the key is found otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * 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.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     put(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
     /**
-     * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>putMany</i> method replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * Removes the key when found. Returns true if the key is found otherwise false is returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>remove</i> method removes the given <i>key</i> when found. Returns true if the key is found otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     remove(key: string): PromiseLike<boolean>;
     /**
-     * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
     /**
-     * If the key is found the value be returned and key will be removed otherwise null will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>getAndRemove</i> method removes the given <i>key</i> and returns it when found otherwise null will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getAndRemove(key: string): PromiseLike<TType | null>;
     /**
-     * If the key is found the value be returned otherwise valueToAdd will be added and returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>getOrAdd</i> method will retrieve the given <i>key</i> if found otherwise <i>valueToAdd</i> will be added and returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): PromiseLike<TType>;
     /**
-     * Will increment the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
+     * Returns true if key exists otherwise false will be returned.
+     * An error will thrown if the key is not a number.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
     increment(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
     /**
-     * Will decrement the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
-     * @throws {StorageError} {@link StorageError}
+     * The <i>decrement</i> method will decrement the given <i>key</i> if found otherwise nonthing will occur.
+     * Returns true if key exists otherwise false will be returned.
+     * An error will thrown if the key is not a number.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
+     * An error will thrown if the key is not a number.
      */
     decrement(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
     /**
-     * @throws {StorageError} {@link StorageError}
+     * The <i>clear</i> method removes all the keys in the storage.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
     clear(): PromiseLike<void>;
+    /**
+     * The <i>getNamespace</i> method return the complete namespace.
+     * @example
+     * ```ts
+     *   const storage = new Storage(new MemoryStorageAdapter(), {
+     *     rootNamespace: "@root/"
+     *   });
+     *
+     *   // Will be "@root/"
+     *   console.log(storage.getNamespace())
+     *
+     *   const storageA = storage.withNamespace("a/");
+     *
+     *   // Will be "@root/a/"
+     *   console.log(storageA.getNamespace())
+     * ```
+     */
+    getNamespace(): string;
+};
+/**
+ * The <i>INamespacedStorage</i> contract defines a way for storing data as key-value pairs independent of storage.
+ * It commes with one extra method which is useful for multitennat applications compared to <i>IStorage</i>.
+ * @group Contracts
+ */
+export type INamespacedStorage<TType = unknown> = IStorage<TType> & {
+    /**
+     * The <i>withNamespace</i> method returns new instance of <i>{@link IStorage}</i> where all the keys will be prefixed with a given <i>namespace</i>.
+     * This useful for multitennat applications.
+     * @example
+     * ```ts
+     * import { Storage, MemoryStorageAdapter } from "@daiso-tech/core";
+     *
+     * (async () => {
+     *   const storage = new Storage(new MemoryStorageAdapter());
+     *
+     *   const storageA = storage.withNamespace("a");
+     *   await storageA.add("a", 1);
+     *
+     *   const storageB = storage.withNamespace("b");
+     *   await storageB.add("b", 2);
+     *
+     *   // Will print { a: 1, b: null }
+     *   console.log(await storageA.getMany(["a", "b"]));
+     * })();
+     *
+     * ```
+     */
+    withNamespace(namespace: string): IStorage<TType>;
 };

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

@@ -12,9 +12,25 @@ export type StorageAdapterTestSuiteSettings = {
     test: TestAPI;
     describe: SuiteAPI;
     beforeEach: typeof beforeEach;
-    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+    createAdapter: () => Promisable<IStorageAdapter>;
 };
 /**
+ * The <i>storageAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IStorageAdapter}</i>.
+ * @example
+ * ```ts
+ * import { storageAdapterTestSuite, MemoryStorageAdapter } from "@daiso-tech/core";
+ * import { expext, test, describe, beforeEach } from "vitest";
+ *
+ * describe("class: MemoryStorageAdapter", () => {
+ *   storageAdapterTestSuite({
+ *     createAdapter: () => new MemoryStorageAdapter(),
+ *     test,
+ *     beforeEach,
+ *     expect,
+ *     describe,
+ *   });
+ * });
+ * ```
  * @group Utilities
  */
-export declare function storageTestSuite(settings: StorageAdapterTestSuiteSettings): void;
+export declare function storageAdapterTestSuite(settings: StorageAdapterTestSuiteSettings): void;

package/dist/types/storage/implementations/storage/_module.d.ts

@@ -1 +1,2 @@
 export * from "../../../storage/implementations/storage/storage";
+export * from "../../../storage/implementations/storage/storage-manager";

package/dist/types/storage/implementations/storage/storage-manager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module Storage
+ */
+import type { INamespacedEventBus } from "../../../event-bus/contracts/_module";
+import type { IStorageFactory, INamespacedStorage, IStorageAdapter, IStorageManager } from "../../../storage/contracts/_module";
+import type { Validator } from "../../../utilities/_module";
+/**
+ * @group Derivables
+ */
+export type StorageManagerSettings<TAdapters extends string = string> = {
+    adapters: Record<TAdapters, IStorageAdapter<any>>;
+    defaultAdapter: NoInfer<TAdapters>;
+    rootNamespace: string;
+    eventBus?: INamespacedEventBus<any>;
+};
+/**
+ * @group Derivables
+ */
+export declare class StorageManager<TAdapters extends string = string, TType = unknown> implements IStorageManager<TAdapters, TType> {
+    private readonly adapters;
+    private readonly defaultAdapter;
+    private readonly rootNamespace;
+    private readonly eventBus?;
+    private validator;
+    constructor(settings: StorageManagerSettings<TAdapters>);
+    use(adapter?: TAdapters): INamespacedStorage<TType>;
+    withValidation<TOutput extends TType = TType>(validator: Validator<TOutput>): IStorageFactory<TAdapters, TOutput>;
+    withType<TOutput extends TType = TType>(): IStorageFactory<TAdapters, TOutput>;
+}